为什么这个Haskell代码编译？

Question

Given:

uncurry :: (a-> b -> c) -> (a,b) -> c    
id :: a -> a

Invoking uncurry id results in a function of type: (b -> c, b) -> c

How do we get this result?

How can you use id (a -> a) as the first parameter to uncurry, which requires a (a -> b -> c) function?

Answer 1

It's easier to understand if we try and look at it from the point of making the types work out: figuring out what we need to do to id 's type to get it to fit the shape required by uncurry . Since we have:

id :: a -> a

we also have:

id :: (b -> c) -> (b -> c)

This can be seen by substituting b -> c for a in the original type of id , just as you might substitute Int instead when figuring out the type of id 42 . We can then drop the parentheses on the right-hand side, since (->) is right-associative:

id :: (b -> c) -> b -> c

showing that id 's type fits the form a -> b -> c , where a is b -> c . In other words, we can reshape id 's type to fit the required form simply by specialising the general type it already has.

Another way to understand this is to see that uncurry ($) also has the type (b -> c, b) -> c . Comparing the definitions of id and ($) :

id :: a -> a
id a = a

($) :: (a -> b) -> a -> b
($) f x = f x

we can make the latter definition more point-free:

($) f = f

at which point the fact that ($) is simply a specialisation of id to a more specific type becomes clear.

Answer 2

How can you use id (a -> a) as the first parameter to uncurry, which requires a (a -> b -> c) function?

Actually, uncurry requires (a -> (b -> c)) function. Can you spot the difference? :)

Omitting parentheses is evil (well, sometimes). It makes it impossible for a novice to decipher Haskell. Of course after you've gathered some experience with the language, you feel like you don't need them at all, anymore.

Here, it all becomes clear once we write out all the omitted parentheses back explicitly:

uncurry :: (a -> (b -> c)) -> ((a,b) -> c)
id      ::  a ->    a

Now, writing uncurry id calls for a type unification of a1 -> a1 with a2 -> (b -> c) . This is straightforward, a1 ~ a2 and a1 ~ (b -> c) . Just mechanical stuff, no creative thinking involved here. So id in question actually has type a -> a where a ~ (b -> c) , and so uncurry id has type (b -> c,b) -> c , by simple substitution of a ~ (b -> c) into (a,b) -> c . That is, it expects a pair of a b -> c function and a b value, and must produce a c value.

Since the types are most general (ie nothing is known about them, and so there's no specific functions to call that might do the trick in some special way), the only way to produce a c value here is to call the b -> c function with the b value as an argument. Naturally, that's what ($) does. So uncurry id == uncurry ($) , although id is most certainly not ($) .