Noel Welsh wrote at 08/31/2010 04:36 PM:
> In general this is a huge problem (equivalent, I think, to the "sufficiently smart compiler" problem, which itself is equivalent to solving AI).
>
What Noel said. Though, it might be a useful thing for the Racket
interpreter (compiler) to have hooks of some kind for pluggable
optimizations. Useful both for practical use and for increasing how
Racket can be used as a language research platform.
As a user, would be nice if I could get a matrix library without special
compiler optimizations by doing:
(require (planet foo/matrix))
Or, if I indicated that I wanted the special compiler optimizations
provided by the module, like:
(require/hooks (planet foo/matrix))
then special optimization code from the foo/matrix module can hook
itself into a compiler phase for my using module. In this example,
perhaps in a phase after macro expansion and with all (current)
references resolved. (I'm thinking of hooks covering only intra-module
stuff for the using module, no access into other modules.)
I don't know how feasible it would be to provide these hooks in a
particular version of Racket. Regarding keeping such hooks from
encumbering evolution of future versions of Racket, would it suffice for
the compiler to not be obligated to call the hooks and, if it does call,
to announce its version when calling the hooks? The hook code would be
responsible for doing the right thing (or nothing) for that particular
Racket version. So, in this example, when a new version of Racket comes
out, the foo/matrix would likely run without requested hook
optimizations until the developer of foo/matrix looks at any changes
made to the internal representations exposed by the hooks in that
version of Racket, and makes any necessary changes to the
optimizations. Importantly, Racket would make no commitment to maintain
the representations between versions, nor to even to document any of the
representations.
It's fortunate that Matthew has seemingly infinite time for all the work
that people would like him to do. :)
I still like the idea of doing the matrix optimizations in pure Racket
with internally-optimizing ADTs with lazy operations, rather than with
syntax extension mini-language, an entire front-end language, or
compiler hooks.
--
http://www.neilvandyke.org/