Determining type of Haskell function - haskell

Question

One past exam question was to state the type of the function ring with definition ring r q p = r (q p). Supposedly the answer is ring :: (b -> c) -> (a -> b) -> (a -> c), but I don't see where this comes from. Surely such a type would indicate that ring only receives two arguments, but in the definition it takes three, so what's going on?

Answer 1

Every function in Haskell takes one parameter. A function can however return a function that takes another parameter. Haskell however introduces some syntax to make it more convenient. A signature (b -> c) -> (a -> b) -> (a -> c) is thus equivalent to (b -> c) -> ((a -> b) -> (a -> c)) or (b -> c) -> (a -> b) -> a -> c.
Let us first analyze the expression:
ring r q p = r (q p)
Since at the moment we do not know much about the type yet, we will first assign some types to the parameters:
r :: a
q :: b
p :: c
ring :: a -> b -> c -> d
Now we can start to determine the types. In the expression, we see q p, this thus means that q is a function, and p a parameter. This thus means that q is a function of type c -> e (with e a type parameter we introduce).
So we derived that:
q :: c -> e
p :: c
q p :: e
Next we see that the result of q p is used as a parameter with r the function, so that means r is a function that takes an e as parameter type. We thus set the type of r to e -> f. We thus know that:
q p :: e
r :: e -> f
r (q p) :: f
Since the result of ring r q p is r (q p), this thus means that the type of ring is:
ring :: (e -> f) -> (c -> e) -> c -> f
or more verbose:
ring :: (e -> f) -> ((c -> e) -> (c -> f))

Answer 2

Let's go step by step into you ring function (known for everybody as compose or .)
here is the story:
ring r q p = r (q p)
if you start with p you can give to it a type, the variable is not bounded or restricted, so it can be variable, generic, so let's choose a name, a
p :: a
now, q has something that you can tell, it takes values of type p as parameter, right? Because it is applied to p , (q p), so, q is a function, and a function has the form (type -> type),
p :: a
q :: (type -> type)
now you can replace the input, q expects a p typed values, and p :: a so:
p :: a
q :: a -> type
again, the type of the return can be the same as the input, but is not restricted to be, so we can use another name to it, let use b
p :: a
q :: a -> b
(q p) :: b
now, what about r ?, r expects the result of (q p) and you know the type, it is b, same logic, r :: type -> type because it is a function
p :: a
q :: a -> b
(q p) :: b
r :: b -> type
and finally, the return type of r is not restricted, so it can be a c type, so:
p :: a
q :: a -> b
(q p) :: b
r :: b -> c
r (q p) :: c
replacing everything in ring:
ring :: (b -> c) -> (a -> b) -> a -> c
ring r q p = r (q p)
see that I didn't use the final parenthesis, because they are not needed, in haskell the functions are curried, so, its true that if you give two functions to ring, it will return a third function of type a -> c
let's see:
ring show (+1)
(+1) :: Num a -> a -> a
show :: Show a => a -> String
ring show (+1) :: (Show a, Num a) => a -> String
and I didn't give the value, so that why you can write ring as:
ring :: (b -> c) -> (a -> b) -> (a -> c)
and remove it to:
ring :: (b -> c) -> (a -> b) -> a -> c
and to see more, check the types of:
ring show :: Show a => (b -> a) -> b -> String
ring show (+1) :: (Show a, Num a) => a -> String
ring show (+1) 2 :: String
ring also can have more extra parenthesis:
ring :: (b -> c) -> ((a -> b) -> (a -> c))
as you can see in ring show it returns ((a -> b) -> (a -> c)) and ring show (+1) returns (a -> c)