haskell type signature question

Question

Can someone explain me, why do these functions have different number of arguments and behavior, but the same type signature, yet they are both correct?

comp1 :: (a -> b) -> (b -> c) -> a -> c
comp1 f g = g.f

comp2 :: (a -> b) -> (b -> c) -> a -> c
comp2 f g x = g (f x)

also, why does comp2 has

comp2 :: (a -> b) -> (b -> c) -> a -> c

instead of something like

comp2 :: a -> (a -> b) -> (b -> c) -> a -> c

?

Thank you.

Answer 1

comp2 f g x = g (f x)

is syntactic sugar for

comp2 = \f -> \g -> \x -> g (f x)

Similarly

comp1 f g = g.f

is sugar for

comp1 = \f -> \g -> g.f

The definition of . is:

f1 . f2 = \x -> f1 (f2 x) -- Names of arguments have been changed to avoid confusion

So if we insert the definition into the desugared form of comp1, we get:

comp1 = \f -> \g -> \x -> g (f x)

This is exactly the same as the desugared form of comp2, so clearly the definitions are equivalent.

Answer 2

comp1 f g = g.f is written in point-free style (not referring to points, but to values). When you call comp1, there is implicitly a third parameter being passed to g.f, which is the composition of the two functions g and f: (g.f) x equals g (f x), i.e. g is passed the result of f x. No parameter x exists in comp1 because it's implicitly passed to the function. (You could think of comp1 as a partially applied or curried function if it makes you feel better.)

comp2's type asks for two functions, one from (a->b) and another (b->c), as well as a parameter of type a. There is no need to put an a -> in its signature.

The two functions are really equivalent; one simply uses some Haskell tricks to be more concise.

Answer 3

Currying. A multi-argument function in ML and Haskell, is just syntactic sugar for a one-argument function that returns a function; the function that it returns takes the remaining arguments.