;;; Let's jump right in. The first form may look a little murky at
;;; first because of the extra lambda.  Try to trace what happens when
;;; you evaluate ((fact1 fact1) 10); you should get 
;;; (* 10 ((fact1 fact1) 9)) and so on.  As you think of this, note
;;; the crucial (h h) at the end.  Why is it necessary?

(define fact1
  (lambda (h)
    (lambda (n)
      (if (= n 1) 
	  (* n ((h h) (- n 1)))))))

;;; So that works and could certainly serve as the answer to, "How do you do
;;; recursion with just lambdas?" But what if we really want to take this,

(define F
  (lambda (h)
    (lambda (n)
      (if (= n 1) 
	  (* n (h (- n 1)))))))

;;; and turn it into a recursive function. Observe that if we already had
;;; a working factorial function 'fact' then,  
;;;          (F fact)  ---> fact.   
;;; So F is waiting for the right function to bootstrap itself! 
;;; The Y combinator is the magic that takes us there. 
;;;          (Y F)     ---> fact    
;;; In other words Y provides a fixed point of F because,
;;;          (F (Y F)) ---> (Y F) 

;;; To frustrate the novice, we should say here, "The rest is just
;;; currying!" First go  back to fact1 again and remove the troublesome 
;;; (h h) by adding another lambda. 

(define fact2
  (lambda (g)
    ((lambda (h)
       (lambda (n)
	 (if (= n 1) 
	     (* n (h (- n 1))))))
     (lambda (m) ((g g) m)))))

;;; This is by no means the only natural way to proceed, but
;;; unfortunately here all roads don't lead to Rome. Next we look
;;; for the correct argument to fact2. We want,
;;;           ((fact2 A) 10) =    10!
;;; or        ((fact2 A) 10) ---> (* 10 ((A A) 9))
;;; So the right A is... fact2! Indeed ((fact2 fact2) n) works.
;;; Cleaning up a little,

(define fact3
  (lambda (g)
      (F (lambda (m) ((g g) m)))))

;;; and finally,

(define fact
  ((lambda (g)
      (F (lambda (m) ((g g) m))))
   (lambda (g)
       (F (lambda (m) ((g g) m))))))

;;; is the factorial function. Now it is clear that the Y combinator should be,

(define Y
  (lambda (f)
    ((lambda (u)
       (f (lambda (x) ((u u) x))))
     (lambda (v)
       (f (lambda (x) ((v v) x)))))))

;;; This is also called the Turing fixed point combinator. How
;;; pleasing and symmetric it looks! For greater obscurity, we could
;;; also compress it as,  

(define Yobs
   (lambda (f)
     ((lambda (f)
	(f f))
      (lambda (u)
	(f (lambda (x) ((u u) x)))))))

;;; which has the effect of inducing a powerful headache.