LispSyntax.jl

It turns out that Julia is ~a lisp, just with a weird syntax. If you look at the metaprogramming facilities, all expressions are first turned into s-exprs while parsing. There is no problem having a LISP syntax for Julia, and in fact this has been implemented! (https://github.com/swadey/LispSyntax.jl) https://docs.julialang.org/en/v1/manual/metaprogramming/

The REPL had a patch, https://github.com/swadey/LispSyntax.jl/issues/36, but for some reason it didn't get released 3 years ago when the patch was actually created.

To be fair to yourself, LispSyntax.jl is more of a proof of concept than something that anyone would want to actually do significant coding in as can be seen by the TODO list in the README[1]. It also hasn't seen any active development in several years. [1] https://github.com/swadey/LispSyntax.jl

You mean like https://github.com/swadey/LispSyntax.jl ?

There's https://github.com/swadey/LispSyntax.jl for that.

Having a language that hides it's lispness behind a python-like syntax can be good for the lisp community though, even if they don't use them. People do have prejudice against those parenthesis, so having an entry point that is "Python-like" (the most popular language for beginners and non programmers) that can still teach the core features of Lisp (everything is an expression, sort of easy AST manipulation, macros, parts of CLOS like multiple dispatch) will only help people appreciate the languages it was inspired on. And possibly they'll also feel the limitations of non sexp macros and decide to actually move to racket or common lisp to free themselves from those restrictions once they become aware of them. Possibly those people will even do something like Clojure for the Julia compiler (a mature version of [1]), with an entire communit

Just swap out the parser ;) -https://github.com/swadey/LispSyntax.jl

Yes, it's a string macro which is essentially a reader macro. We also have regular macros that operate on Julia's AST. There's some really useful and approachable info here: https://docs.julialang.org/en/v1/manual/metaprogramming/inde... You can think of Julia as a Lisp-1 with opt out hygenic macros hiding behind Algol syntax. However, the AST is very lispy: julia> dump(:(x^2 - 1)) Expr head: Symbol call args: Array{Any}((3,)) 1: Symbol - 2: Expr head: Symbol call args: Array{Any}((3,)) 1: Symbol ^ 2: Symbol x 3: Int64 2 3: Int64 1 The `:` is how you quote code in Julia, and `dump` is just a convenient function for printing nested data-structures. Furthermore, you can see this package https://github.com/swadey/LispSyntax.jl for a string ma

I mostly got used to them, but I do enjoy playing around with https://github.com/swadey/LispSyntax.jl for more directly lispy sytanx in Julia.

Considering how close Julia is to Lisp, it could be interesting to have an actual Lisp targeting the Julia compiler, for people who don't want to compromise on s-expr but would still want to have a performance oriented Lisp with access to a lot of scientific computation and ML libraries (and probably better interop compared to Clojure and Java for example). The only work I know for this is: https://github.com/swadey/LispSyntax.jl

I meant that macros being a little harder to use and the result being a little more restricted is the feature, a small protection against the Lisp Curse (if every custom language is just as good as the base language, then no one can agree what the base language should be). Kinda like newer languages kinda avoid inheritance because while it's powerful, it's kinda easy to misuse (though Elixir special 'using' macro is a fantastic simple way to share behavior between modules). And while programmable reader macros allow Lisp to have any syntax you want, they go even further in producing heterogeneous environments in which not even the parsing rules are shared. But you can't just only know the algol/infix way of programming in Lisp since you'll have to see other people code and documentation, and when you use these alternate parsers/extensions