alex-eg
1f445f0f9b
Two things out of one mechanism. `_' as a type means "work it out from
the initializer", so (var n _ (strlen s)) stops needing size-t spelled
out; `type-of' hands a macro the type of an expression, so a macro can
dispatch on what it was handed rather than on what was declared. Both
read the same answers from two sides.
Algorithm W's core, intra-procedural, with the extensions C forces:
- an unknown type, since (include stdio.h) brings in names we never
parsed. Unification is consistency rather than equality, so
anything touching an unparsed declaration stops constraining
instead of rejecting a program that compiled yesterday;
- the usual arithmetic conversions, since `+' is not a function of
one type;
- checking mode for initializers, since #(0 0) has no type of its own
and takes one from its context. #(T : ...) is the way out of that.
What it wanted on the way:
- what type a *name* has, which neither the typedef nor the tag
database recorded. One table serves functions and variables, since
a function type already has a surface spelling;
- a scope chain, so a (var c int 9) inside a do ends with the block;
- form-type, keyed by cons cell, so one form has one type;
- macros expanded during the walk rather than before it, so type-of
is answered in the scope the macro was written in.
Closures take the same machinery: a receiver whose type comes from a
call, captures written (name expr) and typed from the expression, and
conversion from a bare function wherever a closure is expected.
type-match grew `_' on the pattern side, since (closure ((int)) int)
and (closure ((float)) int) were separate clauses for one case.
62 lines
2.3 KiB
Scheme
62 lines
2.3 KiB
Scheme
(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))
|