Question

While studying for a Functional Programming exam, I came across the following questions from a previous test:

t2 = (\x -> \y -> \z -> (x y, x (x z)))

t3 = t2 (take 3 . reverse) mnr mnr

For t2, it is asked to determine the most general type of the statement. The answer appears to be:

(a -> a) -> a -> a -> (a,a)

I am able to find the answer by entering the statement into WinHugs, but how is this answer found? I understand from my previous post that it has something to do with lambda functions though other than that I am at a loss to explain what is going on here.

The second part of the question (t3) then applies two functions to two instances of the variable mnr. For mnr = [0,1,2,3,4,5,6] this results in:

([6,5,4],[4,5,6])

How does this work? The functions take and reverse are clear but how are they applied to the lambda functions in t2?

Answer 1

Let’s start from the middle, at the result.

(x y, x (x z))

because x is being applied to things (y, z, and x z), we know it has the type (a -> ?) where the question mark represents an unknown type. Now, the result of x is being passed to x in x (x z), so its input type must be its output type:

x :: a -> a

Now, x is applied to y and to z, so they both must be of type a. x y and x (x z) are also both of type a (as that is x‘s return type), so t2 returns something of type (a, a).

Putting this together with the type of its arguments (x, y, and z), we get that is has type

(a -> a) -- x's type
-> a -- y's type
-> a -- z's type
-> (a, a) -- the result type

For you second question, let’s first look at what things are bound to what variables in t2‘s definition. The first argument is x, so in this case

x = (take 3 . reverse)

The next argument is y, so

y = mnr

Similarly for z,

z = mnr

The result will be (x y, x (x z)), so let’s evaluate this

(x y, x (x z))
= ((take 3 . reverse) mnr, (take 3 . reverse) ((take 3 . reverse) mnr))
= (take 3 (reverse mnr), take 3 (reverse (take 3 (reverse mnr))))

with this specific case of mnr = [0,1,2,3,4,5,6], we get

= (take 3 (reverse [0,1,2,3,4,5,6]), take 3 (reverse (take 3 (reverse [0,1,2,3,4,5,6]))))
= (take 3 [6,5,4,3,2,1,0], take 3 (reverse (take 3 [6,5,4,3,2,1,0])))
= ([6,5,4], take 3 (reverse [6,5,4]))
= ([6,5,4], take 3 [4,5,6])
= ([6,5,4], [4,5,6])