#Reversing a list#

<OL>
<LI>How would you define an operation to reverse a list? (Don't peek at the
[[lambda_library]]! Try to figure it out on your own.) Choose whichever
implementation of list you like. Even then, there are various strategies you
can use.

(See [[hints/Assignment 4 hint 1]] if you need some hints.)
</OL>


#Comparing lists for equality#

<OL start=2>
<LI>blah
</OL>
<!--
let list_equal =
    \left right. left
                ; here's our f
                (\hd sofar.
                    ; deconstruct our sofar-pair
                    sofar (\might_be_equal right_tail.
                        ; our new sofar
                        make_pair
                        (and (and might_be_equal (not (isempty right_tail))) (eq? hd (head right_tail)))
                        (tail right_tail)
                    ))
                ; here's our z
                ; we pass along the fold a pair
                ; (might_for_all_i_know_still_be_equal?, tail_of_reversed_right)
                ; when left is empty, the lists are equal if right is empty
                (make_pair
                    true ; for all we know so far, they might still be equal
                    (reverse right)
                )
                ; when fold is finished, check sofar-pair
                (\might_be_equal right_tail. and might_be_equal (isempty right_tail))
-->

#Mutually-recursive functions#

<OL start=3>
<LI>blah
</OL>


#Enumerating the fringe of a leaf-labeled tree#

[[Implementing trees]]


<OL start=4>
<LI>blah
</OL>