alternate Y1,Y2 tweak

[lambda.git] / hints / assignment_4_hint_3_alternate_1.mdwn

diff --git a/hints/assignment_4_hint_3_alternate_1.mdwn b/hints/assignment_4_hint_3_alternate_1.mdwn
index c62d620..dd55e05 100644 (file)
--- a/hints/assignment_4_hint_3_alternate_1.mdwn
+++ b/hints/assignment_4_hint_3_alternate_1.mdwn
@@ -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