X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=hints%2Fassignment_4_hint_2.mdwn;h=f9f4cf253a0b938b2d8a877bad7d90dd7051086e;hp=5ee63f556482af650f62bd38b42fdb1501400f1a;hb=HEAD;hpb=d64cb0b28631033972a42593ee17125bbe939605

diff --git a/hints/assignment_4_hint_2.mdwn b/hints/assignment_4_hint_2.mdwn
deleted file mode 100644
index 5ee63f55..00000000
--- a/hints/assignment_4_hint_2.mdwn
+++ /dev/null
@@ -1,73 +0,0 @@
-Hints for `list_equal`.
-
-*	If `left` is `[]`, what does `right` have to be for `left` and `right` to be equal? (Come on, it's not too hard, you can figure it out.)
-
-*	Suppose on the other hand that `left` has head `left_hd` and tail `left_tl`.
-	
-	<OL type=a>
-	<LI>If `right` is then `[]`, are `left` and `right` equal?
-	<LI>If `right` isn't `[]`, and its head isn't equal to `left_hd`, are `left` and `right` equal?
-	<LI>If `right` isn't `[]` and its head *is* equal to `left_hd`, what else has to be the case for `left` and `right` to be equal?
-	</OL>
-
-*	Can you now write a recursive definition of the `list_equal` function?
-What's your base case?
-
-
-<!--
-eql [] l2        = empty l2
-eql (l1h:l1t) l2 = and (not (empty l2))
-                       (l1h == head l2)
-                       (eql l1t (tail l2))
-
-Simple rearangement:
-
-eql []        = \l2 -> empty l2
-eql (l1h:l1t) = \l2 -> and (not (empty l2))
-                       (l1h == head l2)
-                       (eql l1t (tail l2))
-
-and another one rearrangement:
-
-eql []        = \l2 -> empty l2
-eql (l1h:l1t) = let prev = eql l1t
-                in \l2 -> and (not (empty l2))
-                              (l1h == head l2)
-                              (prev (tail l2))
-
-Now it fits the pattern of foldr
-
-So, the end result:
-
-eql = foldr f z
- where
- z = empty
- f h z = \l2 -> and (not (empty l2))
-                    (h == head l2)
-                    (z (tail l2))
--->
-
-<!--
-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))
--->
-