macro-lisp VS hebigo

Rust’s macro system is safe and hygienic, people have implemented lisps in it. I just did a google search to find an example, so I have no idea how well supported this is, https://github.com/JunSuzukiJapan/macro-lisp

You can already have both: https://github.com/JunSuzukiJapan/macro-lisp

Via a lisp macro?

Rust macros can make the language look like anything, even lisp: https://github.com/JunSuzukiJapan/macro-lisp

Why not get the best (?) of both worlds with the macro-lisp crate: https://github.com/JunSuzukiJapan/macro-lisp

A small snippet from the project's examples shows minimal boilerplate between Rust and a native-looking Lisp experience:

After that, I'm going to go back to working on adding some scripting. My attempts at making a Lisp in Rust failed spectacularly, but when trying to find a ready made replacement that's not too big (so not RustPython and not Rhai or Dyon) I found mentions of DSL, which are usually Rust macros, which led me to https://github.com/JunSuzukiJapan/macro-lisp (single file, circa 400 lines, that does basically the whole job I want, i.e. being able to call Rust functions when I need them, e.g. from an in-game console)

The Lissp transpiler incrementally compiles and executes each top-level form to Python. It needs to do this in case there's a macro definition that might affect the compilation of a subsequent form. If it's only executing definitions, this is harmless, but if you want to precompile the main module, it needs the guard, or the side effects will happen too.

If you want Python to be as customizable as Lissp, check out Hissp (and Hebigo).

Python's lambdas can have as many lines as you want. Just wrap parens around it. Hissp uses this form as a compilation target. Its REPL shows the Python compilation. Play around with it til you get it: https://github.com/gilch/hissp

The original Lisp's S-expression syntax was just supposed to be an intermediate language used by the compiler when processing the real language based on M-expressions, which kind of never took off. Numerous alternatives to S-expressions have been proposed, and some retain homoiconicity, another feature diagnostic of a Lisp (and one that ECMAScript lacks). For example, see Hebigo's readme, which shows a direct correspondence between its Python-like syntax and that of Hissp's default reader (Lissp), which uses the S-expressions. Julia can also be written in S-expressions, but this usually only used in macro definitions.

I think LoL is too CL-specific. If you know both languages first, you can pretty much translate, but since they'd be trying to learn Lisp in the first place, this is a bad idea.

On the other hand, [Hissp][1] has a pretty good tutorial for anyone coming from a Python background.

[1]: https://github.com/gilch/hissp

Hebigo: a whitespaceLisp isomorphic to Hissp that looks like Python.