assignment7 tweak
[lambda.git] / lambda_library.mdwn
index f0b4f44..e170dcf 100644 (file)
@@ -12,7 +12,7 @@ and all sorts of other places. Others of them are our own handiwork.
 **Spoilers!** Below you'll find implementations of map and filter for v3 lists, and several implementations of leq for Church numerals. Those were all requested in Assignment 2; so if you haven't done that yet, you should try to figure them out on your own. (You can find implementations of these all over the internet, if you look for them, so these are no great secret. In fact, we'll be delighted if you're interested enough in the problem to try to think through alternative implementations.)
 
 
-       ; booleans
+       ;; booleans
        let true = \y n. y  in ; aka K
        let false = \y n. n  in ; aka K I
        let and = \p q. p q false  in ; or
@@ -25,71 +25,20 @@ and all sorts of other places. Others of them are our own handiwork.
        let iff = \p q. not (xor p q)  in ; or
        let iff = \p q. p q (not q)  in
 
-       ; pairs
+       ;; tuples
        let make_pair = \x y f. f x y  in
-       let get_1st = \x y. x  in ; aka true
-       let get_2nd = \x y. y  in ; aka false
-
-       ; triples
+       let get_fst = \x y. x  in ; aka true
+       let get_snd = \x y. y  in ; aka false
        let make_triple = \x y z f. f x y z  in
 
 
-       ; Church numerals: basic operations
-
+       ;; Church numerals
        let zero = \s z. z  in ; aka false
        let one = \s z. s z  in ; aka I
        let succ = \n s z. s (n s z)  in
        ; for any Church numeral n > zero : n (K y) z ~~> y
        let iszero = \n. n (\x. false) true  in
 
-
-       ; version 3 lists
-
-       let empty = \f z. z  in
-       let make_list = \h t f z. f h (t f z)  in
-       let isempty = \lst. lst (\h sofar. false) true  in
-       let head = \lst. lst (\h sofar. h) junk  in
-       let tail_empty = empty  in
-       let tail = \lst. (\shift. lst shift (make_pair empty tail_empty) get_2nd)
-                               ; where shift is
-                               (\h p. p (\t y. make_pair (make_list h t) t))  in
-       let length = \lst. lst (\h sofar. succ sofar) 0  in
-       let map = \f lst. lst (\h sofar. make_list (f h) sofar) empty  in
-       let filter = \f lst. lst (\h sofar. f h (make_list h sofar) sofar) empty  in ; or
-       let filter = \f lst. lst (\h. f h (make_list h) I) empty  in
-       let singleton = \x f z. f x z  in
-       ; append [a;b;c] [x;y;z] ~~> [a;b;c;x;y;z]
-       let append = \left right. left make_list right  in
-       ; very inefficient but correct reverse
-       let reverse = \lst. lst (\h sofar. append sofar (singleton h)) empty  in ; or
-       ; more efficient reverse builds a left-fold instead
-       ; (make_left_list a (make_left_list b (make_left_list c empty)) ~~> \f z. f c (f b (f a z))
-       let reverse = (\make_left_list lst. lst make_left_list empty) (\h t f z. t f (f h z))  in
-       ; zip [a;b;c] [x;y;z] ~~> [(a,x);(b,y);(c,z)]
-       let zip = \left right. (\base build. reverse left build base (\x y. reverse x))
-                       ; where base is
-                       (make_pair empty (map (\h u. u h) right))
-                       ; and build is
-                       (\h sofar. sofar (\x y. isempty y
-                                               sofar
-                                               (make_pair (make_list (\u. head y (u h)) x)  (tail y))
-                       ))  in
-       let all = \f lst. lst (\h sofar. and sofar (f h)) true  in
-       let any = \f lst. lst (\h sofar. or sofar (f h)) false  in
-
-
-       ; version 1 lists
-
-       let empty = make_pair true junk  in
-       let make_list = \h t. make_pair false (make_pair h t)  in
-       let isempty = \lst. lst get_1st  in
-       let head = \lst. isempty lst err (lst get_2nd get_1st)  in
-       let tail_empty = empty  in
-       let tail = \lst. isempty lst tail_empty (lst get_2nd get_2nd)  in
-       
-
-       ; more math with Church numerals
-
        let add = \m n. m succ n  in ; or
        let add = \m n s z. m s (n s z)  in
        let mul = \m n. m (\z. add n z) zero  in ; or
@@ -101,10 +50,9 @@ and all sorts of other places. Others of them are our own handiwork.
        ; exp b succ ; adds b^exp
        let pow = \b exp s z. exp b s z  in
 
-
        ; three strategies for predecessor
        let pred_zero = zero  in
-       let pred = (\shift n. n shift (make_pair zero pred_zero) get_2nd)
+       let pred = (\shift n. n shift (make_pair zero pred_zero) get_snd)
                ; where shift is
                (\p. p (\x y. make_pair (succ x) x))  in ; or
        ; from Oleg; observe that for any Church numeral n: n I ~~> I
@@ -119,23 +67,21 @@ and all sorts of other places. Others of them are our own handiwork.
        ; from Bunder/Urbanek
        let pred = \n s z. n (\u v. v (u s)) (K z) I  in ; or
 
-                                       
        ; inefficient but simple comparisons
        let leq = \m n. iszero (n pred m)  in
        let lt = \m n. not (leq n m)  in
        let eq = \m n. and (leq m n) (leq n m)  in ; or
 
-
        ; more efficient comparisons, Oleg's gt provided some simplifications
-       let leq = (\base build consume. \m n. n consume (m build base) get_1st)
+       let leq = (\base build consume. \m n. n consume (m build base) get_fst)
                        ; where base is
                        (make_pair true junk)
                        ; and build is
                        (\p. make_pair false p)
                        ; and consume is
-                       (\p. p get_1st p (p get_2nd))  in
+                       (\p. p get_fst p (p get_snd))  in
        let lt = \m n. not (leq n m)  in
-       let eq = (\base build consume. \m n. n consume (m build base) get_1st)
+       let eq = (\base build consume. \m n. n consume (m build base) get_fst)
                        ; 2nd element of a pair will now be of the form (K sthg) or I
                        ; we supply the pair being consumed itself as an argument
                        ; getting back either sthg or the pair we just consumed
@@ -144,8 +90,8 @@ and all sorts of other places. Others of them are our own handiwork.
                        ; and build is
                        (\p. make_pair false (K p))
                        ; and consume is
-                       (\p. p get_2nd p)  in
-       
+                       (\p. p get_snd p)  in
+
 
        ; -n is a fixedpoint of \x. add (add n x) x
        ; but unfortunately Y that_function doesn't normalize
@@ -161,17 +107,17 @@ and all sorts of other places. Others of them are our own handiwork.
                                                (make_triple (succ cur) false (succ sofar)) ; continue
                                ))  in
        ; or
-       let sub = (\base build consume. \m n. n consume (m build base) get_1st)
+       let sub = (\base build consume. \m n. n consume (m build base) get_fst)
                        ; where base is
                        (make_pair zero I) ; see second defn of eq for explanation of 2nd element
                        ; and build is
                        (\p. p (\x y. make_pair (succ x) (K p)))
                        ; and consume is
-                       (\p. p get_2nd p)  in
+                       (\p. p get_snd p)  in
 
 
-       let min = \m n. sub m (sub m n) in
-       let max = \m n. add n (sub m n) in
+       let min = \m n. sub m (sub m n)  in
+       let max = \m n. add n (sub m n)  in
 
 
        ; (m/n) is a fixedpoint of \x. add (sub (mul n x) m) x
@@ -206,10 +152,9 @@ and all sorts of other places. Others of them are our own handiwork.
                                ; and build is
                        (\t. make_triple I succ (K t))
                                ; and mtail is
-                               (\dhead d. d (\dz mz df mf drest sel. drest dhead (sel (df dz) (mf mz))))
-       in
-       let div = \n d. divmod n d get_1st  in
-       let mod = \n d. divmod n d get_2nd  in
+                               (\dhead d. d (\dz mz df mf drest sel. drest dhead (sel (df dz) (mf mz))))  in
+       let div = \n d. divmod n d get_fst  in
+       let mod = \n d. divmod n d get_snd  in
 
 
        ; sqrt n is a fixedpoint of \x. div (div (add n (mul x x)) 2) x
@@ -230,14 +175,134 @@ and all sorts of other places. Others of them are our own handiwork.
                ))  in
 
 
-       ; Rosenbloom's fixed point combinator
-       let Y = \f. (\h. f (h h)) (\h. f (h h)) in
-       ; Turing's fixed point combinator
+       ;; fixed point combinators
+       ; Curry/Rosenbloom's
+       let Y = \f. (\h. f (h h)) (\h. f (h h))  in
+       ; Turing's
        let Theta = (\u f. f (u u f)) (\u f. f (u u f))  in
 
 
-       ; length for version 1 lists
-       let length = Y (\self lst. isempty lst 0 (succ (self (tail lst))))  in
+       ; now you can search for primes, do encryption :-)
+       let gcd = Y (\gcd m n. iszero n m (gcd n (mod m n)))  in ; or
+       let gcd = \m n. iszero m n (Y (\gcd m n. iszero n m (lt n m (gcd (sub m n) n) (gcd m (sub n m)))) m n)  in
+       let lcm = \m n. or (iszero m) (iszero n) 0 (mul (div m (gcd m n)) n)  in
+
+
+       ;; version 1 lists
+       let empty = make_pair true junk  in
+       let make_list = \h t. make_pair false (make_pair h t)  in
+       let isempty = \lst. lst get_fst  in
+       let head = \lst. isempty lst err (lst get_snd get_fst)  in
+       let tail_empty = empty  in
+       let tail = \lst. isempty lst tail_empty (lst get_snd get_snd)  in
+
+       let length = Y (\length lst. isempty lst 0 (succ (length (tail lst))))  in
+       let fold = Y (\fold lst f z. isempty lst z (f (head lst) (fold (tail lst) f z)))  in
+       let map = \f. Y (\map lst. isempty lst empty (make_list (f (head lst)) (map (tail lst))))  in
+       let filter = \f. Y (\filter lst. isempty lst empty (f (head lst) (make_list (head lst)) I (filter (tail lst))))  in
+
+
+       ;; version 3 (right-fold) lists
+       let empty = \f z. z  in
+       let make_list = \h t f z. f h (t f z)  in
+       let isempty = \lst. lst (\h sofar. false) true  in
+       let head = \lst. lst (\h sofar. h) err  in
+       let tail_empty = empty  in
+       let tail = \lst. (\shift. lst shift (make_pair empty tail_empty) get_snd)
+                               ; where shift is
+                               (\h p. p (\t y. make_pair (make_list h t) t))  in
+       let length = \lst. lst (\h sofar. succ sofar) 0  in
+       let map = \f lst. lst (\h sofar. make_list (f h) sofar) empty  in
+       let filter = \f lst. lst (\h sofar. f h (make_list h sofar) sofar) empty  in ; or
+       let filter = \f lst. lst (\h. f h (make_list h) I) empty  in
+       let singleton = \x f z. f x z  in
+       ; append [a;b;c] [x;y;z] ~~> [a;b;c;x;y;z]
+       let append = \left right. left make_list right  in
+       ; very inefficient but correct reverse
+       let reverse = \lst. lst (\h sofar. append sofar (singleton h)) empty  in ; or
+       ; more efficient revappend, reverse
+       ; revappend [a;b;c] [x;y] ~~> [c;b;a;x;y]
+       ; make_left_list a (make_left_list b (make_left_list c empty)) ~~> \f z. f c (f b (f a z))
+       let revappend = (\make_left_lst left right. left make_left_list right) (\h t f z. t f (f h z))  in
+       ; from Oleg, of course it's the most elegant
+       let revappend = \left. left (\hd sofar. \right. sofar (make_list hd right)) I  in
+       let rev = \lst. revappend lst empty  in
+       ; zip [a;b;c] [x;y;z] ~~> [(a,x);(b,y);(c,z)]
+       let zip = \left right. (\base build. reverse left build base (\x y. reverse x))
+                                          ; where base is
+                                          (make_pair empty (map (\h u. u h) right))
+                                          ; and build is
+                                          (\h sofar. sofar (\x y. isempty y
+                                                                                          sofar
+                                                                                          (make_pair (make_list (\u. head y (u h)) x)  (tail y))
+                                          ))  in
+       let all = \f lst. lst (\h sofar. and sofar (f h)) true  in
+       let any = \f lst. lst (\h sofar. or sofar (f h)) false  in
+
+
+       ;; left-fold lists
+       let make_list = \h t f z. t f (f h z)  in
+       let head = \lst. lst (\h sofar. (K (sofar (K h))) ) (\k. k err) I  in
+       let tail = \lst. (\shift. lst shift (\a b. a tail_empty) I I)
+                               (\h p. p (\j a b. b empty) (\t a b. b (\f z. f h (t f z))) )  in
+
+
+       ;; version 5 (CPS right-fold) lists
+       ; [] is \f z c a. c z
+       ; [1] is \f z c a. f 1 z c a
+       ; [1;2] is \f z c a. f 2 z (\z. f 1 z c a) a
+       ; [1;2;3] is \f z c a. f 3 z (\z. f 2 z (\z. f 1 z c a) a) a
+       let empty = \f2 z continue_handler abort_handler. continue_handler z  in
+       let isempty = \lst larger_computation. lst
+                       ; here's our f2
+                       (\hd sofar continue_handler abort_handler. abort_handler false)
+                       ; here's our z
+                       true
+                       ; here's the continue_handler for the leftmost application of f2
+                       larger_computation
+                       ; here's the abort_handler
+                       larger_computation  in
+       let make_list = \h t. \f2 z continue_handler abort_handler.
+               t f2 z (\sofar. f2 h sofar continue_handler abort_handler) abort_handler  in
+       let head = \lst larger_computation. lst
+                       ; here's our f2
+                       (\hd sofar continue_handler abort_handler. continue_handler hd)
+                       ; here's our z
+                       err
+                       ; here are our continue_handler and abort_handler
+                       larger_computation unused  in
+       let tail_empty = empty  in
+       let tail = \lst larger_computation. lst
+                       ; here's our f2
+                       (\h sofar continue_handler abort_handler. continue_handler (sofar (\t y. make_pair (make_list h t) t)))
+                       ; here's our z
+                       (make_pair empty tail_empty)
+                       ; here are our continue_handler and abort_handler
+                       (\sofar. sofar (\x y. larger_computation y)) unused  in
+
+       ;; CPS left-fold lists
+       ; [] is \f z c a. c z
+       ; [1] is \f z c a. f 1 z  (\z. c z) a
+       ; [1;2] is \f z c a. f 1 z (\z. f 2 z (\z. c z) a) a
+       ; [1;2;3] is \f z c a. f 1 z (\z. f 2 z (\z. f 3 z (\z. c z) a) a) a
+       let make_right_list = make_list  in
+       let make_list = \h t. \f2 z continue_handler abort_handler.
+               f2 h z (\z. t f2 z continue_handler abort_handler) abort_handler  in
+       let head = \lst larger_computation. lst
+                       ; here's our f2
+                       (\hd sofar continue_handler abort_handler. abort_handler hd)
+                       ; here's our z
+                       err
+                       ; here are our continue_handler and abort_handler
+                       larger_computation larger_computation  in
+       let tail = \lst larger_computation. lst
+                       ; here's our f2
+                       (\h sofar continue_handler abort_handler. continue_handler (sofar (\j a b. b empty) (\t a b. b (make_right_list h t)) ) )
+                       ; here's our z
+                       (\a b. a tail_empty)
+                       ; here are our continue_handler and abort_handler
+                       (\sofar. sofar larger_computation larger_computation) unused  in
+
 
 
        true
@@ -259,21 +324,21 @@ and all sorts of other places. Others of them are our own handiwork.
 
 <!--
        ; my original efficient comparisons
-       let leq = (\base build consume. \m n. n consume (m build base) get_1st (\x. false) true)
+       let leq = (\base build consume. \m n. n consume (m build base) get_fst (\x. false) true)
                        ; where base is
                        (make_pair zero I) ; supplying this pair as an arg to its 2nd term returns the pair
                        ; and build is
                        (\p. p (\x y. make_pair (succ x) (K p))) ; supplying the made pair as an arg to its 2nd term returns p (the previous pair)
                        ; and consume is
-                       (\p. p get_2nd p)  in
-       let lt = \m n. not (leq n m) in
+                       (\p. p get_snd p)  in
+       let lt = \m n. not (leq n m)  in
        let eq = (\base build consume. \m n. n consume (m build base) true (\x. false) true)
                        ; where base is
                        (make_pair zero (K (make_pair one I)))
                        ; and build is
                        (\p. p (\x y. make_pair (succ x) (K p)))
                        ; and consume is
-                       (\p. p get_2nd p)  in ; or
+                       (\p. p get_snd p)  in ; or
 -->
 
 <!--
@@ -296,3 +361,32 @@ and all sorts of other places. Others of them are our own handiwork.
 
 
 -->
+
+<!--
+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))
+
+; most elegant
+let list_equal = \left. left (\hd sofar. \right. and (and (not (isempty right)) (eq hd (head right))) (sofar (tail right))) isempty
+
+-->
+