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 u = Y (\u g. (\f x. A) (u g)) in
+ let g = Y ( \g. (\f y. B) (u g)) in
let f = u g in
C
- We abstract the Y1 and Y2 combinators from this as follows:
+ We could abstract Y1 and Y2 combinators from this as follows:
let Yu = \ff. Y (\u g. ff ( u g ) g) in
let Y2 = \ff gg. Y ( \g. gg (Yu ff g ) g) in
* Here's the same strategy extended to three mutually-recursive functions. `f`, `g` and `h`:
- let v = Y (\v g h x. (\f. A) (v g h)) in
- let w = Y ( \w h x. (\g. (\f. B) (v g h)) (w h)) in
- let h = Y ( \h x. (\g. (\f. C) (v g h)) (w h)) in
+ let v = Y (\v g h. (\f x. A) (v g h)) in
+ let w = Y ( \w h. (\g. (\f y. B) (v g h)) (w h)) in
+ let h = Y ( \h. (\g. (\f z. C) (v g h)) (w h)) in
let g = w h in
let f = v g h in
D