author Jim Pryor Sat, 16 Oct 2010 18:14:08 +0000 (14:14 -0400) committer Jim Pryor Sat, 16 Oct 2010 18:14:08 +0000 (14:14 -0400)
Signed-off-by: Jim Pryor <profjim@jimpryor.net>

index c62d620..dd55e05 100644 (file)
@@ -2,22 +2,22 @@ Alternate strategy for Y1, Y2

*      This is (in effect) the strategy used by OCaml. The mutually recursive:

-       let rec
-               f x = A  ; A may refer to f or g
-       and
-               g y = B  ; B may refer to f or g
-       in
-               C
+               let rec
+                       f x = A  ; A may refer to f or g
+               and
+                       g y = B  ; B may refer to f or g
+               in
+                       C

-is implemented using regular, non-mutual recursion, like this (`u` is a variable not occurring free in `A`, `B`, or `C`):
+       is implemented using regular, non-mutual recursion, like this (`u` is a variable not occurring free in `A`, `B`, or `C`):

-       let rec u g x = (let f = u g in A)
-       in let rec g y = (let f = u g in B)
-       in let f = u g in C
+               let rec u g x = (let f = u g in A)
+               in let rec g y = (let f = u g in B)
+               in let f = u g in C

-or, expanded into the form we've been working with:
+       or, expanded into the form we've been working with:

-       let u = Y (\u g x. (\f. A) (u g)) in
-       let g = Y (\g y. (\f. B) (u g)) in
-       let f = u g
+               let u = Y (\u g x. (\f. A) (u g)) in
+               let g = Y (\g y. (\f. B) (u g)) in
+               let f = u g