Hints for reverse.

• If left and right are two v3 lists, what is the result of:

left make_list right

• What is reverse []? What is reverse [c]? What is reverse [b;c]? How is it related to reverse [c]?

• How is reverse [a;b;c] related to reverse [b;c]?

• Getting any ideas?

Another strategy.

• Our version 3 lists are right-folds. That is, [a;b;c] is implemented as:

\f z. f a (f b (f c z))


which is the result of first combining the base value z with the rightmost element of the list, using f, then combining the result of that with the next element to the left, and so on.

A left-fold on the same list would be:

\f z. f (f (f z a) b) c


which is the result of first combining the base value z with the leftmost element of the list, then combining the result of that with the next element to the right, and so on.

It's conventional for f to take the accumulated value so far as its second argument when doing a right-fold, and for it to take it as its first argument when doing a left-fold. However, this convention could be ignored. We could also call this the left-fold of [a;b;c]:

\f z. f c (f b (f a z))

• Getting any ideas?

• Our make_list function for taking an existing, right-fold-based list, and a new element, and returning a new right-fold-based list, looks like this:

let make_list = \hd tl. \f z. f hd (tl f z)


How would you write a make_left_list function, that takes an existing, left-fold-based list, like \f z. f c (f b z), and a new element, a, and returned the new, left-fold based list:

\f z. f c (f b (f a z))