The definition of curry
is:
curry :: ((a, b) -> c) -> a -> b -> c
curry f = \x y -> f (x, y)
If we substitute that in:
\x y z -> (curry (==) x y) z
\x y z -> ((==) (x, y)) z -- Function application
\x y z -> (==) (x, y) z -- Remove parentheses (function application is left associative in Haskell, so they are unnecessary here)
\x y z -> (x, y) == z -- Convert to infix
We can tell right away that z
must be some kind of tuple as well, or else this last line wouldn't type check since both arguments of ==
must have the same type.
When we look at the definition of the tuple instance for Eq
, we find
instance (Eq a, Eq b) => Eq (a, b) where
(x, y) == (x', y') = (x == x') && (y == y')
(This isn't spelled out in the source code of the standard library, it actually uses the "standalone deriving" mechanism to automatically derive the instance for the (Eq a, Eq b) => (a, b)
type. This code is equivalent to what gets derived though.)
So, in this case, we can treat ==
as though it has the type
(==) :: (Eq a, Eq b) => (a, b) -> (a, b) -> Bool
Both x
and y
must have types that are instances of Eq
, but they don't need to be the same instance of Eq
. For example, what if we have 12
and "abc"
? Those are two different types but we can still use our function, since they are both instances of Eq
: (\x y z -> (x, y) == z) (12, "abc") (30, "cd")
(this expression type checks and evaluates to False
).