[Haskell-beginners] curry in a hurry

[prad]

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?


-- 
In friendship,
prad

                                      ... with you on your journey
Towards Freedom
http://www.towardsfreedom.com (website)
Information, Inspiration, Imagination - truly a site for soaring I's