With Clojure, If you understand the JVM type system and performance, you can also write high performance DSLs using Clojure macros. https://github.com/clojure/core.logic allegedly is a project along these lines, but I haven't looked too much into it. It heavily uses Clojure protocols (which map to Java interfaces) for performance. I had been working on a code generator for Clearley, which sits neglected on my hard drive, but is able to perform just a little slower than unoptimized hand-written parsers. Since in Clojure compile/runtime separation is optional and off by default, you can use Clojure to generate Clojure code, making life a lot easier.
genFoo :: String -> DecsQ
genFoo name = [d| instance Foo $(return t) where quux = $(return f) |]
where f = VarE . mkName ("quuxify" ++ name)
t = ConT (mkName name)
genFoos :: [String] -> DecsQ
genFoos = foldl' (liftM2 (++)) (return []) . map genFooLisps generally run in an image, meaning you have full access to he full state of the program including the compiler/macro expander/etc, which you can run at runtime.
So what about a program that reads a protocol off the wire, expands/compiles it to x86_64 assembly, and communicates over the wire with it (all in the same process and without calling any external compiler).
Or maybe a program that collects runtime performance statistics and uses some stochastic method to improve the 'hot' pieces of code.
[0] https://news.ycombinator.com/item?id=516208
[1] https://news.ycombinator.com/user?id=ntoshev
[2] https://news.ycombinator.com/item?id=516038