
LLVM Clojure Bindings - llambda
https://github.com/jasonjckn/llvm-clojure-bindings
======
jasonjackson
I'm the author of this project. I think of this project as a technology demo.
I wanted to how difficult it would be to write a minimalist compiler with LLVM
-- it was pretty quick & easy.

This is a great educational project as the code is short and to the point.

For my parsing code: [https://github.com/jasonjckn/llvm-clojure-
bindings/blob/mast...](https://github.com/jasonjckn/llvm-clojure-
bindings/blob/master/src/parser.clj) I'm using a combinator parser library.
This code both parses and builds the AST in one pass.

The AST unsurprisingly looks like LISP code, here's an example AST
[https://github.com/jasonjckn/llvm-clojure-
bindings/blob/mast...](https://github.com/jasonjckn/llvm-clojure-
bindings/blob/master/src/example_ast.clj)

After that, all that's left is calling LLVM C API through JNA:
[https://github.com/jasonjckn/llvm-clojure-
bindings/blob/mast...](https://github.com/jasonjckn/llvm-clojure-
bindings/blob/master/src/ast.clj)

One advantage of using LLVM is you can leverage the C Standard Library from
your code. In the example program, I forward declare 'cos' and 'printf', and
LLVM takes care of linking the functions.

LLVM also supports JIT compilation, so you could do some really cool stuff.

Stay tuned for the next compiler I'm working on which will compile the
majority of Java 2.0 to x86.

------
swannodette
I was excited to find out that the developer, Jason Jackson, had actually used
core.logic (<https://github.com/clojure/core.logic>) to implement a type
checker as well as used core.match (<https://github.com/clojure/core.match>)
for pattern matching in his compiler projects.

As these tools mature - I think over time Clojure could provide a pretty sweet
library ecosystem for folks looking to design new languages.

~~~
jasonjackson
Just to clarify I'm actually working on a second compiler project written in
Clojure. It's my 2nd project that uses core.logic and core.match extensively.
Core.Logic was the perfect abstraction for doing all the type checking -- I'm
really grateful for David's work/help.

I'll open source this 2nd compiler project in a couple months. This will
really show the power of Clojure as David said.

~~~
markokocic
Native Clojure in Clojure?

~~~
jasonjackson
The compiler is written in Clojure. It'll compile Java ~2.0 to native x86. I
haven't decided what backend i'm using yet, or just output ASM.

------
phren0logy
I would love to use clojure as a data analysis language. Although incanter is
nice, it's slower than I would prefer. Perhaps being able to use a use a non-
java linear algebra library would help?

If so, this seems like a great first step.

------
jared314
I wonder if a ClojureScript LLVM backend would work.

~~~
swannodette
! Would love to find out :) It's a open goal to make ClojureScript pluggable.

~~~
snprbob86
I'm by no means a Lisper or "compiler guy", but I found the ClojureScript
compiler to be extremely hackable. It looks like it would form an excellent
basis for Clojure-in-Clojure, which would surely support additional pluggable
backends. Seems like that is the plan.

