This package provides a lisp-to-julia syntax translator with convenience macros that let you do this:
lisp"(defn fib [a] (if (< a 2) a (+ (fib (- a 1)) (fib (- a 2)))))"
@test lisp"(fib 30)" == 832040
@test fib(30) == 832040
LispSyntax.jl is implemented as an expression translator between lisp/clojure-like syntax and julia's AST. Julia's compiler, JIT and multiple-dispatch infrastructure is used for code generation and execution. Because of this, LispSyntax.jl is not really clojure or lisp in most meaningful ways. The semantics are entirely julia-based (which are very similar to scheme/lisp in many ways). The net result is that LispSyntax.jl is really an alternative S-expression-like syntax for julia, not an implemention of clojure or lisp.
(def symbol init)
(quote form)
(defn symbol [param*] expr*)
(defmacro symbol [param*] expr*)
(lambda [param*] expr*)
(fn [param*] expr*)
(let [binding*] expr*)
(global symbol*)
(while test expr*)
(for [binding*] expr*)
(import package*)
LispSyntax.jl
.(global symbol*)
.let
, fn
parameter lists, etc.). This is not
currently implemented.defn
are translated to normal julia function
expressions. This means the
act as named lambdas in local scope.LispSyntax.jl
look like
standard Lisp macros but because expressions are special objects in
julia, S-expressions returned from macros require a special
translation step to generate julia expression trees. The result is
that LispSyntax.jl
macros are directly translated into Julia macros and
must be called via special syntax (e.g. (@macro expr)
). Macro hygiene
follows the Julia approach of hygenic-by-default with explicit escaping
using esc
. This is the opposite of Clojure's macros which use explicit
hygiene with specially named variables.@r_str
which in Julia can be called via r""
, it is
currently necessary to call these via standard macro syntax:
(@r_str "string")
LispSyntax.jl provides a convenience REPL, alleviating one from having to
type lisp"( ... )"
for each top level expression. In order to use REPL
mode, simply initialize it:
julia> using LispSyntax
julia> LispSyntax.init_repl()
REPL mode Lisp Mode initialized. Press ) to enter and backspace to exit.
At this point, type )
, and you're ready to Lisp:
jλ> (* 2 (reduce + (: 1 6)))
42
jλ> (defn fib [a]
(if (< a 2)
a
(+ (fib (- a 1)) (fib (- a 2)))))
fib (generic function with 1 method)
jλ> (fib 10)
55
To return to the Julia prompt, simply type the backspace type or
Ctrl-C
. Once there, you'll still have access to the fuctions you
defined:
julia> fib
fib (generic function with 1 method)
julia> fib(10)
55
You may also create a customized REPL.
using
is currently
implemented and confusingly, it matches Clojure's import form.