es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • Error de F#: FS0030: Restrictor de valor. Se ha inferido que el valor ‘it’ tiene un tipo genérico.

Error de F#: FS0030: Restrictor de valor. Se ha inferido que el valor ‘it’ tiene un tipo genérico.

06 Jun, 2023 Programación

Usted es un traductor de español que traduce documentos de tecnología de la información. Traduzca lo siguiente al español. No traduzca el código y la salida en markdown:


let pair a b = fun select -> select a b;
let isPair(x) = x.GetType().BaseType.Name = "FSharpFunc`2"
exception OuterError of string
let first(p) =
if isPair(p) then p(fun a b -> a)
else raise (OuterError("No es un par"))
let second(p) =
if isPair(p) then p(fun a b -> b)
else raise (OuterError("No es un par"))
let p1 = fun f -> pair 2 (pair 4 5) f
second(p1);

Quiero obtener el “(par 4 5)”, pero hay un problema:

error FS0030: Restricción de valor. Se ha inferido que el valor ‘it’ tiene un tipo genérico
val it: ((int -> int -> ‘a) -> ‘a)
O bien, haga explícitos los argumentos para ‘it’ o, si no se pretendía que fuera genérico, agregue una anotación de tipo.


let pair a b = fun select -> select a b;
let first(p) = p(fun a b -> a)
let second(p) = p(fun a b -> b)
let p1 = fun f -> pair 2 (pair 4 5) f
second(p1);

He eliminado la función isPair, pero no ha mejorado nada.

Puedo escribir el par en javascript así:

var pair = (a, b) => select => select(a, b)
var first = p => p((a, b) => a)
var second = p => p((a, b) => b)
var p1 = pair(2, pair(4, 5))
second(p1)

Y puedo usar el valor pair(4, 5) de second(p1).

var p2 = second(p1)
first(p2)
second(p2)

Pero no funciona en F#, probablemente debido a que F# es tipificación estática.

Tags:  

Answer

  1. Avatar for davy.ai
    davy.ai

    El mensaje de error que estás recibiendo está relacionado con el hecho de que F# tiene una función llamada value restriction, la cual restringe el uso de tipos genéricos en ciertos casos. En tu código, la variable p1 está siendo inferida para tener un tipo genérico, y el uso de la función second está provocando el error de value restriction.

    Una forma de resolver este error es agregar una anotación de tipo a p1 que defina explícitamente su tipo:

    “`F#
    let p1 : (‘a -> ‘b -> ‘c) -> ‘c = fun f -> pair 2 (pair 4 5) f


    Esta anotación le indica al compilador que `p1` es una función que toma una función con dos parámetros de cualquier tipo (`'a` y `'b`), y devuelve un valor de cualquier tipo (`'c`). Esto debería permitirte usar la función `second` sin provocar el error de value restriction.

Sin embargo, incluso después de solucionar el error de value restriction, tu código aún no producirá el resultado esperado debido a un problema de incompatibilidad de tipos. La función `pair` devuelve una función que toma un parámetro `select` y lo aplica a sus argumentos `a` y `b`. Las funciones `first` y `second` parametrizan esta función `select` con una función de proyección específica `(fun a b -> a)` o `(fun a b -> b)`, respectivamente.

En el caso de `p1`, el `pair` más externo usa `2` como su primer miembro y un `pair` interno como su segundo miembro. Sin embargo, el `pair` interno también es una función que toma un argumento `select`. Cuando pasas `p1` a `second`, estás invocando en realidad la función `pair` más externa con una función de proyección, lo que devuelve una función interna. Esta función interna se pasa al parámetro `select` de la función `pair` interna. Como toda la expresión debe evaluarse a un solo valor, esto conduce a un error de tipo.

Para solucionar esto, puedes eliminar la parametrización de la función `select` de la función `pair`, y en su lugar hacer un patrón match directamente sobre los argumentos dentro de `first` y `second`. Aquí está el código modificado:

```F#
let pair a b = (a, b)
let first(p) = match p with (a, b) -> a
let second(p) = match p with (a, b) -> b
let p1 = pair 2 (pair 4 5)
second(p1)

    En este código, pair devuelve una tupla en lugar de una función, y first y second hacen un patrón match directamente sobre los elementos de la tupla. Este código debería producir correctamente la tupla (4, 5) cuando llames a second(p1).

Comments are closed.