Finished 12.

12-ypp/13.rkt

@@ -0,0 +1 @@
+#lang pl broken

12-ypp/main.rkt

@@ -1 +1,74 @@
 #lang pl broken
+
+(define (Z f)
+  ((λ (x) (f (λ (v) ((x x) v))))
+   (λ (x) (f (λ (v) ((x x) v))))))
+
+(rewrite (define/rec (f x ...) E) =>
+         (define f
+           (let ([g (Z (λ (f)
+                         (λ (_) ; Ignore this arg.
+                           (λ (x ...)
+                             (let ([f (f #f)]) ; #f is bogus.
+                               E)))) )])
+             (g #f)))) ; #f is bogus.
+
+; ackermann : Nat Nat -> Nat
+(define/rec (ackermann m n)
+  (cond [(zero? m) (+ n 1)]
+        [(zero? n) (ackermann (- m 1) 1)]
+        [else (ackermann (- m 1) (ackermann m (- n 1)))]))
+
+(test (ackermann 3 3) => 61)
+
+(rewrite (letfuns ([(f x) E] ...) B) =>
+         (let ([g (Z (λ (funs)
+                       (λ (fname)
+                         (match fname
+                           ['f (λ (x)
+                                 (let ([f (funs 'f)] ...)
+                                   E))]
+                           ...))))])
+           (let ([f (g 'f)] ...)
+             B)))
+
+(test (letfuns ([(even? n) (if (= n 0) #t (odd? (- n 1)))]
+                [(odd? n) (if (= n 0) #f (even? (- n 1)))])
+               (even? 123)) => #f)
+
+(rewrite (letfunss ([(f x ...) E] ...) B) =>
+         (let ([g (Z (λ (funs)
+                       (λ (name)
+                         (match name
+                           ['f (λ (x ...)
+                                 (let ([f (funs 'f)] ...)
+                                   E))]
+                           ...))))])
+           (let ([f (g 'f)] ...)
+             B)))
+
+(define balanced?
+  (letfunss ([(balanced? l)
+              (and (not (null? l))
+                   (symbol=? (first l) 'left)
+                   (symbol=? (last l) 'right)
+                   (check l 0))]
+             [(check l amount)
+              (cond [(null? l) (= amount 0)]
+                    [(symbol=? (first l) 'left)
+                     (check (rest l) (add1 amount))]
+                    [(symbol=? (first l) 'right)
+                     (and (> amount 0)
+                          (check (rest l) (sub1 amount)))]
+                    [else (check (rest l) amount)])]
+             [(last l)
+              (cond [(null? (rest l)) (first l)]
+                    [else (last (rest l))])])
+            balanced?))
+
+(test (balanced? '()) => #f)
+(test (balanced? '(left right)) => #t)
+(test (balanced? '(left left right right)) => #t)
+(test (balanced? '(left right right)) => #f)
+(test (balanced? '(left right right)) => #f)
+(test (balanced? '(left fasdkfhaskdjhfkajshdfkajhsdkfjhaskdjfhasdhf right)) => #t)