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.
56 lines
1.7 KiB
Scheme
56 lines
1.7 KiB
Scheme
(import
|
|
scheme
|
|
(only fmt fmt)
|
|
(chicken base)
|
|
(chicken plist)
|
|
(chicken string))
|
|
|
|
(define (cat-syms s-1 s-2)
|
|
(fmt #f s-1 s-2))
|
|
|
|
(define (cat sym-1 sym-2)
|
|
(string->symbol (cat-syms sym-1 sym-2)))
|
|
|
|
;;; The reader keeps `;' comments as (comment "...") forms so they can
|
|
;;; be re-emitted into the generated C. In a macro body a comment
|
|
;;; should be a call which does nothing, hence this one
|
|
(define (comment . _)
|
|
(void))
|
|
|
|
(define (register-macro name arglist body)
|
|
(put! name 'sex-macro
|
|
`(lambda ,arglist
|
|
;; A macro body is ordinary Scheme, evaluated at compile
|
|
;; time. It gets `cat' for building names, and read access to
|
|
;; the type database
|
|
(import scheme
|
|
(scheme base)
|
|
;; a type is a list, so a macro reading one wants
|
|
;; `(third type)' rather than `(caddr type)'
|
|
(only srfi-1 first second third fourth fifth last)
|
|
(only sex-macros cat comment)
|
|
(only types get-type-info get-tag-info get-fields
|
|
get-underlying-type type-match type-pattern-matches?
|
|
map-fields
|
|
get-name-type get-return-type type-of))
|
|
,@body)))
|
|
|
|
(define (get-macro name)
|
|
(eval (get name 'sex-macro)))
|
|
|
|
(define (macro? form)
|
|
(and (list? form)
|
|
(symbol? (car form))
|
|
(get (car form) 'sex-macro)))
|
|
|
|
(define (apply-macro form)
|
|
(assert (macro? form)
|
|
(fmt #f (car form) " is not a macro"))
|
|
(apply (get-macro (car form))
|
|
(cdr form)))
|
|
|
|
(define (defmacro form)
|
|
(let ((arglist (car form))
|
|
(body (cdr form)))
|
|
(register-macro (car arglist) (cdr arglist) body)))
|