Claims to have all the syntax covered, but not a single example of specifying lifetimes or the turbofish, some of the trickiest rust syntax
You can also drop into direct Rust with the (rust "...") macro if I forgot to implement anything
Show HN: Rust but Lisp
51–60 of 79 posts
Re: Show HN: Rust but Lisp
#52Should be named "Rutht"
Re: Show HN: Rust but Lisp
#53does there exist something that can do the opposite?
some pre-processor that "compiles into rust" from less awful syntax?
Re: Show HN: Rust but Lisp
#54So if I wanted to actually use this and I write some rust-but-lisp code and there's a compile error, will it show me a nice error message with an arrow pointing to where the error happened in my lisp code? Can I use the amazing `rust-analyzer` LSP to get cool IDE features? I suspect the answer is no, but these might be good further prompts to use.
Good idea! I'm adding error messages + spans ala ariadne now
Re: Show HN: Rust but Lisp
#55Readers may enjoy my lisp, Loon, which takes heavy inspiration from Rust https://loonlang.com/guide/ownership
That page is beautiful! What ssg / theme are you using to build it?
Thanks :) Check out the code - it's Loon! https://github.com/ecto/loon/blob/main/web/src/pages/guide/o...
Re: Show HN: Rust but Lisp
#56Readers may enjoy my lisp, Loon, which takes heavy inspiration from Rust https://loonlang.com/guide/ownership
How does ownership work within the Lisp tree structure?, What is the difference between ownership on this setting and ARC?
ARC refcounts everything (many owners) whereas Loon refcounts only inside immutable shared tree nodes (one owner per handle)
Re: Show HN: Rust but Lisp
#57Unfortunately, given the clear LLM basis of this project, s-expressions aren't a great choice. I've found coding agents struggle really hard with s-expression parentheses matching. Much better to give them something more M-expr styled, I think a grammar that is LL(1) is probably helpful in that regard. Basically the more you can piggyback on the training data depth for algol-style and pythonic languages the better.
If anyone is curious, I've been making this using DeepSeek v4 Flash with Claude Code as the harness
Re: Show HN: Rust but Lisp
#58Readers may enjoy my lisp, Loon, which takes heavy inspiration from Rust https://loonlang.com/guide/ownership
Honestly, that's very cool
That was basically my intent with this project, but I took the laziest way to get there lol
Re: Show HN: Rust but Lisp
#59Readers may enjoy my lisp, Loon, which takes heavy inspiration from Rust https://loonlang.com/guide/ownership
I like the ubiquitous type inference. It reminds me a bit of ELSA for Emacs Lisp: https://github.com/emacs-elsa/Elsa. In particular, type aware macros have been on my wishlist forever: there's no good reason I shouldn't be able to write, e.g. an elisp or CL/SBCL compiler-macro that specializes an operation based on its inferred type. In normal lisps, it's hard to get even the declared types.
That said, I wish that part of Loon were less coupled to the allocation model though. What made you opt for mandatory manual memory management in an otherwise high-level language? And effects?
There are two things common in language design that, honestly, strike me as unnecessary:
1. manual allocation and lifetime stacking, and
2. algebraic effects.
On 1: I think we often conflate the benefits of Rust-style mutability-xor-aliased reference discipline with the benefits of using literal malloc and free. You can achieve the former without necessitating the latter, and I think it leads to a nicer language experience.
It's not just true that GC "comes with latency spikes, higher memory usage, and unpredictable pauses" in any meaningful way with modern implementations of the concept. If anything, it leads to more consistent latency (no synchronous Drop of huge trees at unpredictable times) and better memory use (because good GCs use compressed pointers and compaction).
On 2: I get non-algebraic effects for delimited continuations. But lately I've seen people using non-flow-magical effects for everything. If you need to talk to a database, pick a database interface and pass an object implementing the interface to the code that needs it. Effects do basically the same thing, but implicitly.
Re: Show HN: Rust but Lisp
#60Anyone working on something similar that compiles to go?