I've said this before but I think fennel is one of the most impressive languages around. Lua has a good reputation but I've used it professionally and find it one of the more practically painful languages to work in. Apparently fennel's author agrees, because fennel is laser-focused on correcting exactly its worst problems.

AND/BUT one of fennel's impressive things is that it sticks rigidly to lua runtime semantics. Which I found a little repulsive at first but has huge benefits in its context. You can drop fennel into any version of lua on any runtime (bc they vary a lot) and it works the same. You can hook the single-file fnl compiler into lua's module loader and mix fennel files into an existing lua program, freely sharing functions and metatables both ways.

Very flexible and powerful because of that tradeoff. Anywhere I have to use lua now I am actually using fennel.

The downside is this choice precludes it from having the clojure-like data structures and reference types. It could add a new standard library but doesn't, limiting itself to a handful of special forms (notably pattern match thank god) that mix nicely with the existing lua primitives. It looks like TimL has gone the other way with that decision, which I also appreciate. Makes it maybe a less flexible general-purpose lua replacement/extension, but probably makes it more powerfully suited for the specific purpose it'll be used for.

I use Aniseed, but it's worth noting that it's something like a "framework" on top of Fennel and Neovim. So I also want to shout out Hotpot, which is more of a simple plugin that allows you to put plain Fennel files in your runtime path, without any additional "framework" to learn.

That said, I think the framework that Aniseed introduces is really nice, and I think would be useful for writing general purpose programs outside of Neovim.

I'll second Conjure. I use it for (Gerbil) Scheme, and it makes it so much better. I really wish there was better support for non-Emacs editors in the Lisp ecosystem. Or really just a stronger Lisp ecosystem...

And its half doesn’t include the repetitive stress injuries ;)

> slow

There's quite a good chance that even the most complicated Neovim setup is faster than Emacs. Emacs lisp is notoriously slow, while Neovim uses LuaJIT, which is _very_ fast.

A few years ago I would have hated you for this comment but after switching to Emacs, this comment is actually spot on.

Just in case you though VimL was too easy and want to add manual memory management in on top of it? ;)

I think a huge compatibility layer would also needs to be part of that. Most IDEs probably use a completely different vocabulary and set of concepts than Emacs, starting with buffers and mode lines and minibuffers and modes.

> Wouldn't this basically convert any IDE into Emacs if the user wants it?

Emacs Lisp is only part of the equation. You need the all of the programmability that implements 90% of Emacs in Lisp (all of the standard library functions, the display engine, etc).

From the readme:

  Start a repl with :TLrepl. Tab complete is your friend. The first time may take several seconds (if your computer is a piece of shit), but compilation is cached, so subsequent invocations will be super quick, even if Vim is restarted.

To be honest, I would prefer Clojure to Elisp too.

But to be frank, it's hard for me to imagine people preferring Vim over anything that isn't ed ;). Although, at least using ed you don't need to type the colons :)

Clojure still uses S expressions, it just has more than just lists available. Square brackets don't make lists, they make vectors. Commas are always optional. I don't know what you mean by "arbitrary lists where pairs which belong together aren't grouped", but maybe you mean maps or sets, which are also not lists but a different data type.

  user=> (type [])
  clojure.lang.PersistentVector
  user=> (type '()) ; gotta quote the list
  clojure.lang.PersistentList$EmptyList
  user=> (type {})
  clojure.lang.PersistentArrayMap
  user=> (type #{})
  clojure.lang.PersistentHashSet

Different data types are used for different things. Vectors have more natural insertion behavior, so most people use them where that might happen.

  user=> (conj '(1) 2)
  (2 1)
  user=> (conj [1] 2)
  [1 2]

Hmm, that's

    > "There are things I'll never understand."
    "There are things I'll never understand."

for me. But

    > (cond ("There are things I'll never understand." 'true))
    true

works.

Seriously I'm glad to not understand everything, that would be quite worrying and/or boring.