mbase

ly be represented as such. Of course, there is also an alternative style, which may be preferable if you have debugging tools for designing your compiler passes at least equivalent to the Lisp macro expansion debugging. You can simply write your entire DSL compiler as a single function, and then wrap it into a macro, as `(defmacro mydsl (&rest args) (mydsl-compiler args))`. This way, the same compiler infrastructure can be reused for an interpreted or partially interpreted version of your DSL, if you need it. Still, all the same rules apply to how the passes are implemented in that compiler function. Another very useful trick is to make your DSLs composable, which is easy if you split your compilation pipeline into separate macro expansion passes. Multiple DSLs may easily share features of their internal IRs or even front-end languages, so any new DSL would simply cherry-pick features from a number of existing DSLs and wrap them into a simple front-end. This degree of composability is simply impossible with the function-based interpreted eDSLs. A can recommend taking a look at the Nanopass [1] framework, which is built around this very ideology, or at my own DSL construction framework [2]. [1] http://andykeep.com/pubs/np-preprint.pdf And some examples: https://github.com/cisco/ChezScheme https://github.com/eholk/harlan [2] https://github.com/combinatorylogic/mbase

emental compilation of individual functions, modify/debug a running program, and especially extension with macros. Racket is a batteries-included LISP with IDE, active community, and strong support for DSL's. Now, ML's strengths are strong typing, type inference, easily integrated into formal verification, lots of prior work/tools in that (incl compilers), and easy to model w/ macros. Embedding ML in a LISP gives me the best of both worlds. I once did this in a 4GL to have rapid development with extraction to C/C++ with safety, portability, etc stuff auto-inserted. Easy parsing also lets you extract to a number of ML's or LISP's to use their tooling to catch extra errors in yours. I've only run into two tools outside of Racket doing this sort of thing: https://github.com/combinatorylogic/mbase http://julialang.org/ Mbase is used in commercial tools for static analysis, etc. It's a LISP and toolset custom designed for easily making things like compilers that comes with many DSL's for specific tasks, including ML. Julia raises the bar for 3GL language experience via a compiler written in LISP (femtolisp) that immediately translates the AST's into LISP expressions and works from there. It's more advanced than, but similar advantages to, the 4GL I wrote as it combines best properties of static typing, dynamic productivity, macros, and C support. Underlying LISP that enables that is only about 1,000loc to implement IIRC. So, that's my thinking. I also thought of implementing the tool in MLton, too, but such things are even easier when your tooling and language makes extractions trivial. ;)

l spit out Prolog equations for each expression node that needs typing. Then execute your Prolog code and get your types back. An implementation won't look any more complicated than a formal specification of a type system in a paper, using the type equations (as in [3]). [1] https://github.com/combinatorylogic/mbase [2] http://minikanren.org/ [3] http://stackoverflow.com/questions/12532552/what-part-of-mil...