;;  ------------------------------------------------------------------------
;; |                                                                        |
;; |   FILE           :  why-of-y.rkt                                       |
;; |   AUTHOR         :  Eugene Wallingford                                 |
;; |   CREATION DATE  :  2015/03/10                                         |
;; |                                                                        |
;; |   DESCRIPTION    :  Gabriel's examples that evolve the Y combinator,   |
;; |                     plus a couple of examples of its use.              |
;; |                                                                        |
;;  ------------------------------------------------------------------------

#lang racket

; ----------------------------------------------------
; The examples Gabriel uses to explore the problem ...
; ----------------------------------------------------

(let ((g (lambda (h n)
           (if (< n 2) 1 (* n (h h (- n 1)))))))
  (g g 10))

(letrec ((f (lambda (n m)
              (if (< n 2) m (f (- n 1) (* m n))))))
  (f 10 1))

(letrec ((f (lambda (n)
              (lambda (m)
                (if (< n 2) m ((f (- n 1)) (* m n)))))))
  ((f 10) 1))

(let ((g (lambda (h)
           (lambda (n)
             (if (< n 2) 1 (* n ((h h) (- n 1))))))))
  ((g g) 10))

(let ((g (lambda (h)
           (lambda (n)
             (let ((f (lambda (q n)
                        (if (< n 2) 1 (* n (q (- n 1)))))))
               (f (h h) n))))))
  ((g g) 10))

(let ((g (lambda (h)
           (lambda (n)
             (let ((f (lambda (q)
                        (lambda (n)
                          (if (< n 2) 1 (* n (q (- n 1))))))))
               ((f (h h)) n))))))
  ((g g) 10))

(let ((f (lambda (q)
           (lambda (n)
             (if (< n 2) 1 (* n (q (- n 1))))))))
  (let ((g (lambda (h)
             (lambda (n)
               ((f (h h)) n)))))
    ((g g) 10)))

; ---------------------------------
; And here it is: the Y combinator.
; ---------------------------------

(define Y
  (lambda (f)
    (let ((g (lambda (h)
               (lambda (n)
                 ((f (h h)) n)))))
      (g g))))

; -------------------------------------------
; factorial rewritten using the Y combinator:
; -------------------------------------------

(define factorial
  (lambda (n)
    (let ((f (Y (lambda (h)
                  (lambda (n)
                    (if (< n 2)
                        1
                        (* n (h (- n 1)))))))))
      (f n))))

; ---------------------------------------------------------------------
; Just some diddling I did later.  The first uses Y to define a length
; function for lists.  The second creates a factorial function from the
; very first (g g n) example at the top of this file.
; ---------------------------------------------------------------------

(define count
  (lambda (lst)
    (let ((f (Y (lambda (h)
                  (lambda (lst)
                    (if (null? lst)
                        0
                        (+ 1 (h (cdr lst)))))))))
      (f lst))))

(define funny-factorial
  (lambda (n)
    (let ((g (lambda (h n)
               (if (< n 2)
                   1
                   (* n (h h (- n 1)))))))
      (g g n))))

; ---------------------------------------------------------------------