I'm sure a more thorough answer would come from a more experienced Haskell user, but I'm gonna go and through my two cents just in case it helps: part 1: 'f' takes one argument (albeit one which is not concrete), 'g' takes two arguments. The Integer/Num discrepancy you experience is due to ghci pushing the types a bit... put your code in a file for better results. part 2: 'f x y' has this type: f :: (Num t) => t -> t -> t which you could read as... f :: (Num t) => t -> (t -> t) ... to make the curry'ing more evident. You'd see that 'f' takes a single argument, a 't' which belongs to type-class Num, and returns some unknown function with type 't -> t' (where the type constrain for 't' still holds). However, to keep it simple, just say that 'f' takes two arguments ;) part 3: I refuse to put myself through that twisted experiment of yours :P Seriously, though, I have no sufficient knowledge to answer with confidence. El sáb, 03-07-2010 a las 15:19 -0700, prad escribió:
today i'm trying to understand curry and uncurry (in 3 parts with specific questions labelled as subsections of the parts).
part 1
if we have
f (x,y) = x + y this is a function working on a single argument (x,y) albeit composed of 2 parameters. however, since all functions are curried in haskell (read that here: http://www.haskell.org/haskellwiki/Currying), what is really happening is
(f x) y or specific to this case (+ x) y since f ends up being (+) as defined.
now if we write g = curry f we are naming a function whose purpose is to (f x) whatever comes its way allowing us to do neat things like:
map (g 3) [4,5,6] [7,8,9]
which we can't do by map (f 3) [4,5,6] because f :: (Num t) => (t, t) -> t meaning f - is a function ... the (Num t) - applies itself ... the => - to a Pair of (Num t)s - gives back a Num t
1.1 am i reading the type statement correctly?
while g :: Integer -> Integer -> Integer means g takes an Integer, applies itself and that Integer to another Integer and computes another Integer.
1.2 how come these are Integer suddenly and not Num t?
this is a problem because while i can do f (2.3,9.3) i get an error when i try (g 2.3) 9.3 ghci wants an instance declaration for (Fractional Integer) which puzzles me because g came about through currying f which is fine with fractions.
part 2
now the next discovery is really strange to me.
if i name
f x y = x + y we see f :: (Num a) => a -> a -> a which looks like the curried form of f (x,y) in fact that's what it exactly is and i can do map (f 3) [4,5,6] [7,8,9] just as i did with g before!!
which is what the wiki statement says too:
f :: a -> b -> c is the curried form of g :: (a, b) -> c
however, it starts by stating:
"Currying is the process of transforming a function that takes multiple arguments into a function that takes just a single argument and returns another function if any arguments are still needed." http://www.haskell.org/haskellwiki/Currying
2.1 so does all this mean that
f (x,y) is the function that takes multiple arguments and not a single argument as i initially thought
and
f x y is the function that actually takes a single argument twice?
part 3
some of the above seems to be confirmed by looking at these types
c x y = x + y c :: (Num a) => a -> a -> a so that's curried
u (x,y) = x + y u :: (Num t) => (t,t) -> t so that's uncurried
:t uncurry c uncurry c :: (Num a) => (a, a) -> a
:t curry u curry u :: (Num a) => a -> a -> a
but
:t uncurry u uncurry u :: (Num (b -> c)) => ((b -> c, b -> c), b) -> c we're trying to uncurry something that is already uncurried
and
:t curry c curry c :: (Num (a, b)) => a -> b -> (a, b) -> (a, b) we're trying to curry something that is already curried
3.1 just what are these strange looking things and how should their types be interpreted?