Buenas , no entiendo como resolver este ejercicio.
al decirte que qux f == flip $ foldl (λr x→f x:r) .
No tengo idea como comprobarlo asi , yo lo estuve viendo si saturaba la funcion osea hacer algo asi como :
qux f [1,2] [3,4]=flip $ fold(λr x→f x:r) [1,2] [3,4] entonces seria flip ( fold(λr x→f x:r) [1,2] [3,4]) no? y esto no me anda por que flip recibe una funcion y dos elementos y fold devuelve una lista.
Gracias
Cuidado que estás teniendo un error al saturar las aplicaciones, una forma simple de evitar ese error es poner paréntesis sobre lo que querés saturar. Es decir que si tenés:
qux f == flip $ foldl (λr x→f x:r)
primero lo escribo
(qux f) == (flip $ foldl (λr x→f x:r))
y ahora agrego los argumentos
(qux f) [1,2] [3,4] == (flip $ foldl (λr x→f x:r)) [1,2] [3,4]que equivale a poner
qux f [1,2] [3,4] == flip (foldl (λr x→f x:r)) [1,2] [3,4]
AH, claro ahora tiene mas sentido.
Gracias!..........
Otra pregunta:
El ejercicio 9 tampoco lo entiendo.
Osea ahora viendolo mejor , el tipo de uc no es ese.
Pero no se como darme cuenta por que cuando hacemos uncurry f :: (X,Y)->Z si f::X->Y->Z.
en este caso f=curry donde curry::((a,b)->c)->a->b->c esto no cumple con la definicion de f.
me fije con el compildor y es como que X=(a,b)->c Y=a Z=b->c
pues unurry curry :: ((a, b) -> c, a) -> b -> c
No entiendo .
El tipo de uc es
uc :: ((a, b) -> c, a) -> b -> c
porque es uncurry aplicado a curry.
De todas las expresiones hay una sola que compila, las otras son aplicaciones incorrectas de uc.
Hola, no me doy cuenta como llegas al tipo de uc
porque uc= uncurry curry
curry :: (a,b) -> c) -> a -> b -> c
uncurry :: a -> b -> c -> (a,b) -> c)
entonce mi razonamiento es:
uc:: ((a,b) -> c) -> (a,b) -> c)
en que me estoy equivocando?
gracias, slds sandra
Hola, capaz te ayude pensarlo de la siguiente forma:
uncurry::(x->y->z)->(x,y)->z
curry::((a,b)->c)->a->b->c
y por lo tanto curry::((a,b)->c)->a->(b->c)
Como lo que querés ahora es aplicar uncurry a curry, te queda claro que lo que "entra" en x tendrá el tipo ((a,b)->c), el tipo y será a y el tipo z será (b->c).
Entonces razonando así, el tipo de uc será (x,y)->z (el tipo de la función no currificada que devuelve uncurry) con x, y, z siendo los tipos que dije antes.
Entonces:
uc::((a,b)->c, a) -> (b->c)
Espero sirva, saludos.
Son bienvenidas las correcciones/críticas a la forma de proceder.
