"Partially evaluating" fexprs?
(Note: this post assumes some familiarity with Kernel.)
Now that we've seen the resurrection of fexprs, I think it might be time to find out how to implement macro-like fexprs efficiently.
Let's take as an example the definition of
($define! $lambda ($vau (formals . body) env (wrap (eval (list* $vau formals #ignore body) env))))
When the programmer writes
But given that a fexpr's body contains arbitrary Kernel code, this seems to require some form of "partial evaluation" or "abstract interpretation"... On the positive side, it seems intuitively doable - after all, the inputs to a fexpr are known, and if we have the programmer add some declaration that a fexpr has no side-effects, the compiler can go ahead and expand it at will. (Obviously, JIT recompilation is required in the general case - redefining a fexpr at runtime is possible just as redefining a function is.)
I'd be grateful for any ideas ideas and/or pointers!
[Edit: Ah, I guess I'll have to wade through Partial Evaluators for Scheme and Functional Programming Languages. PE'ing macro-like fexprs still seems much simpler than the general case: you only have to deal with terminating, side-effect-free computations, and moreover, the inputs are fully known - i.e. exactly the subset of computations that correspond to procedural macros. The case of non-terminating fexprs could be simply handled by aborting after a fixed number of reductions, emitting a warning, and leaving the code as-is for the usual runtime evaluation.]
Active forum topics
New forum topics