(input)
(output "direct: 120"
        "fac: 120 3628800"
        "fib: 55 6765"
        "applied on the spot: 120")
(return 0)

;;; A fixed point built out of closures, which is the hardest thing to
;;; ask of them: recursion with no recursive function anywhere, only
;;; self-application.
;;;
;;; Self-application needs `x x' and so a recursive type, which is
;;; spelled here by routing it through a named struct whose field is a
;;; closure whose own signature mentions that struct. The generated
;;; closure struct is written before `struct rec' is, so this only
;;; compiles because a forward declaration is emitted ahead of both.
;;;
;;; Note what `fix' captures: a *pointer* to the knot, not the knot. A
;;; closure is a code pointer beside N bytes of environment, so
;;; capturing one by value would need N >= 8 + N. No budget makes that
;;; true, and the static assertion says so rather than letting it
;;; corrupt anything.

(include stdio.h)

(struct rec ((f (closure (((* (struct rec))) (int)) int))))

;;; Takes a step that expects itself, returns an ordinary closure with
;;; the self-application hidden inside
(fn fix ((step (* (struct rec)))) (closure ((int)) int)
  (return (closure ((n int)) int (step)
            (return ((-> step f) step n)))))

(pub fn main () int
  (var fac-knot (struct rec))
  (= (. fac-knot f)
     (closure ((self (* (struct rec))) (n int)) int ()
       (if (<= n 1) (return 1))
       (return (* n ((-> self f) self (- n 1))))))

  ;; the knot applied to itself directly, without fix
  (printf "direct: %d\n" ((. fac-knot f) (& fac-knot) 5))

  (var fib-knot (struct rec))
  (= (. fib-knot f)
     (closure ((self (* (struct rec))) (n int)) int ()
       (if (< n 2) (return n))
       (return (+ ((-> self f) self (- n 1))
                  ((-> self f) self (- n 2))))))

  ;; one combinator, two different recursions
  (var fac (closure ((int)) int) (fix (& fac-knot)))
  (var fib (closure ((int)) int) (fix (& fib-knot)))
  (printf "fac: %d %d\n" (fac 5) (fac 10))
  (printf "fib: %d %d\n" (fib 10) (fib 20))

  ;; the combinator's result invoked where it is returned, with no
  ;; intervening `var' -- the receiver's type is the return type of the
  ;; signature it came from, which is what the name table records
  (printf "applied on the spot: %d\n" ((fix (& fac-knot)) 5))
  (return 0))