Estimados, aquí se presenta la función:
dup x = (x, x)
Entiendo que cuando se hace (dup . dup) x, entiendo que es una composición de funciones, donde primero se hace dup x (que devuelve (x, x)), y a eso se le vuelve aplicar dup (dup (x, x) = ((x, x), (x, x))).
Lo que no entiendo es el error que devuelve (dup dup) x.
Alguien me puede corregir si lo anterior esta bien y explicarme el segundo caso?
En el caso de (dup dup) hay que tener en cuenta que tenemos una aplicación, por lo que el segundo dup es el argumento que se le pasa al primero.
Sabemos que dup tiene tipo:
dup :: a -> (a, a)
para no entreverarnos vamos a decir que el dup de la izquierda tiene tipo a1 -> (a1,a1) y el de la derecha tiene tipo a2 -> (a2,a2)
Entonces podemos unificar:
a1 = a2 -> (a2,a2)
Por lo que:
(dup dup) :: (a2 -> (a2,a2), a2 -> (a2,a2))
O lo que es lo mismo:
(dup dup) :: (a -> (a,a), a -> (a,a))
es decir que la aplicación retorna un par de funciones (dup).saludos
Pero si el segundo dup es el argumento que se le pasa al primer dup (y dup :: a -> (a, a)), entonces no quedaría así (primero lo escribo en lenguaje natural):
(dup dup) es una función que recibe a -> (a, a) (este es el argumento que le pasa el segundo dup al primer dup) y devuelve (a -> (a, a), a -> (a, a)).
O sea, (dup dup) :: a -> (a, a) -> (a -> (a, a), a -> (a, a))?
Estoy ignorando algo de lo que explicaste o en realidad está bien lo que indico?
Si una función f tiene tipo f :: a -> b
y la aplicamos a una expresión e de tipo e :: a
entonces el resultado de la aplicación queda de tipo (f e) :: b
Lo mismo pasa con (dup dup), su tipo es el tipo de lo que retorna el dup de la izquierda.