Aniseed is also used by Conjure (Interactive development environment for neovim, used for evaluating Fennel code inside of neovim), which is also made by the same author. Really great plugin for doing Clojure development with neovim. https://github.com/Olical/conjure
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.
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.
“Is this a joke?
If you mean the 6,000 lines of working code, then no, I poured hundreds upon hundreds of very serious hours into that. But if you're referring to the fact it's woefully underdocumented, adds considerable overhead to an already slow host platform, and ultimately unlikely to gain any traction, then yeah, probably.”
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.
Not sure why performance matters in this case anyways though.
Obviously hard to compare because they don’t run the same packages but would still be interesting to see ballpark figures of setups with roughly equivalent functionality.
> Master Pope once dreamt he was an Emacs user. When he awoke, he exclaimed:
> “I do not know if I am Tim Pope dreaming I am an Emacs user, or an Emacs user dreaming I am Tim Pope!”
---
Tangentially related: asking around in fora and in person, I was surprised to see that many plugin writers have had very good experience with the new Vimscript, and even prefer it to the more general purpose Lua (I was expecting the opposite). I myself have not used any Vimscript, but I am tempted to take a look at the new language.
I mean, I know elisp is not the most efficient of Lisp compilers but doing so for a new IDE opens the door for all available codes and plugins people have written for emacs throughout the years.
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).
Emacs lisp has, as far as I can tell, no advantages. It isn't especially good at text editing. It introduces differences from more popular lisp dialects. Anything it offers could be a library in some other lisp.
Clojure on the other hand, has a couple of nice syntax innovations and smooth default data structures.
Emacs Lisp (elisp) is a language specifically created as a scripting language for an editor, maintained by an organization, with one compiler (AFAIK) and 99% of usage is within Emacs.
It's not hard to imagine people preferring Clojure before elisp, especially outside of Emacs.
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 :)
We've come full circle.
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
user=> (conj '(1) 2)
(2 1)
user=> (conj [1] 2)
[1 2]=> true
> "There are things I'll never understand."
"There are things I'll never understand."
> (cond ("There are things I'll never understand." 'true))
true
Seriously I'm glad to not understand everything, that would be quite worrying and/or boring.
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.