Why Fennel?

I think Fennel and Janet went separate ways fairly early on, and the creator of Fennel focussed primarily on Janet whilst the current maintainer of Fennel is responsible for much (most?) of what you see in Fennel today...So some very different design choices between the two languages, i believe.

I moved my Hammerspoon config to Fennel and haven't looked back either. The code becomes much more concise vs Lua.

https://github.com/kbd/setup/blob/master/HOME/.hammerspoon/i...

I’ve been thinking about doing this, but then reminding myself that this is not a wise use of my time lol. However, this looks pretty nice. I might have to do it.

Thanks for sharing your setup, I’ll be stealing some ideas.

I have a goal to move my Neovim config to LunarML one of these days. I too would love better ergonomics over Lua.

Can nvim read it natively or do you need to transpile it?

So basically Emacs with Elisp replaced with Fennel and a more responsive UI...

> is a boon

A boon is a good thing. I think you meant a problem?

Don't forget Terra as well: https://terralang.org/

I'm a big fan of moonscript, but occasionally wish it was still being improved and worked on. Yuescript¹ looks like it fixes most of my bugbears with moonscript, and is for the most part a faster² drop-in replacement.

There was s little discussion here ~18 months ago³, but it will feel largely circular if you look at it as people are suggesting fennel there ;)

¹ https://github.com/pigpigyyy/Yuescript

² This probably only matters if you have tonnes of moonscript, not just a little neovim/mpv/awesomewm config or something.

³ https://news.ycombinator.com/item?id=29903133

Are you using Moonscript for nvim config or something else?

What makes Fennel a bit different is that it is a Lisp inspired by Clojure. If for any reason neither of these ever interested you, then, yes, Fennel would not feel any different to you.

I'm not an expert, but my understanding is the Lua has a very limited grammar that is specifically designed to be parsed in a single pass. This precluded Lua from performing arity checks on function calls.

Fennel does support arity checks but it comes with a runtime cost since it's implemented as a separate Lua call after being transpiled from Fennel.

It's a runtime check. The following fennel:

    (fn add-1 [x] (+ x 1))

    (lambda add-2 [x] (+ x 2))

transpiles to the following lua:

    local function add_1(x)
      return (x + 1)
    end
    local function add_2(x)
      _G.assert((nil ~= x), "Missing argument x on /home/sullyj3/tmp/fn-vs-lambda/fnl/x.fnl:3")
      return (x + 2)
    end
    return add_2

IIRC (and I remember it quite vaguely from some random blog post on the Internet) the Lua implementation uses some trick that greatly speeds up setting up and tearing down activation frames (and has also something to do with the ability to easily cross-call into C back to Lua again?), but it hinges on that argument-passing/result-returning semantics being "use nils for missing stuff, throw away the extras" so e.g. Python can't use it to speed up its implementation of function calls.

Unfortunately, I can't find that blog post so take my words with a grain of salt.

This is mostly based on my experience in the past with Lua circa 2015 when I developed a GUI using Crank Storyboard Engine and needed to write some stuff in C because the Lua equivalent code was too CPU-intensive.

If I remember correctly, Lua is a stack-based VM. What this means is that every piece of data has a corresponding location on a stack data structure in-memory. Function arguments are pushed into the stack as-needed and popped in the function context, and vice-versa for the function return values.

If you wanted arity-checking in this context, you'd have to confirm that you got exactly the right number of elements on the stack, meaning there would be an extra branch in every function call. This might reduce performance if the branch predictor gets it wrong. Plus there would need to be extra instructions to count and to check the count for each pop off the stack in the context of the function call.

This is from the perspective of calling C functions in Lua, so it's probably more complicated for the VM itself when it's running native Lua code.

Declaring a function with `lambda` prepends runtime nil checks for each argument to the function body (excluding optional args-- specified with a question mark, eg. `?x`-- and variable arguments, eg. `...`[1]).

This Fennel:

  (fn foo [x y ...]
    (print x y ...))

  (lambda bar [x ?y ...]
    (print x ?y ...))

...transpiles to this Lua:

  local function foo(x, y, ...)
    return print(x, y, ...)
  end
  local function bar(x, _3fy, ...)
    _G.assert((nil ~= x), "Missing argument x on test.fnl:3")
    return print(x, _3fy, ...)
  end

[1] Fennel's alternative `& xs` vargs format does create a runtime check in functions declared with lambda, but it always evaluates to true because it simply nil-checks the table (here `xs`) that it dumps Lua `...` vargs into.

My memory of this is hazy, in part because I wasn't a C programmer in those days, but ISTR C used to do this too. I think prototypes were added (and required) only by the time ANSI got involved.

Maybe some other OF can confirm/contradict?

Because it’s an extra runtime check vs a direct lua call

Arity explanation: https://en.wikipedia.org/wiki/Arity

From the blurb you quoted, it sounds like Lua doesn't check function argument arity natively, and fennel can. This means that fennel applies a runtime check to validate if a function was called with an expected arity, and if not, propagates an error (however Lua does that, I do not know), hence why arity checked functions are not as performant.

I think they meant speed of implementation.

Caveat: I haven't used Fennel but just inferring from what makes sense...

The Lua VM that they compile to already handles missing arguments with some attendant but unavoidable performance cost.

Fennel's own `lambda` form that they layer on top does check for missing arguments, but it must do so by generating extra Lua code to do those checks. That additional code has a runtime cost.

Using `fn` avoids that extra generated code and its cost.

If Fennel had its own runtime and VM, then the performance story for how missing arguments are handled would be different.

It does! I came in here expecting it was going to be about food and was disappointed.

Genuinely an incredibly flexible, amazing vegetable!

I think (and am not alone) that indentation based languages are easier for beginners to learn.

The fact that indentation (whether significant to syntax or not)helps readability is something I hope I need not demonstrate since indenting is near universal in languages that use explicit delimiters.

So beginners learning a language with delimiters need to learn both delimiters and indentation, and then learn that while the latter helps them more, it's actually just the former that is required.

For beginners, mental load is death by a thousand cuts, so it may make more of a difference then an experienced programmer thinks.

[Edit]

My first reaction was just the benefits for beginners of indentation e syntax. I personally have a subjective feeling of advantages for non beginners to delimiter based syntax (I use common lisp regularly), but I have fairly low confidence in that, while I'm pretty sure of the advantages to beginners for indentation.

Nobody ever heard of python oneliners, for a start.

Structural editing, macros, homoiconicity.

I mean it is lua that has two different ways to loop, with different syntax and semantics, but calls them both "for." "Numeric for" and "generic for" are the official names, with separate pages in the docs. Having different names for them seems like a reasonable and not that surprising choice.

Ranges are not a first-class object in Lua, the range-based for loop is basically a hardcoded special case.

You can hardly write anything in any mainstream Lisp without using macros.

False, like with any feature there are use cases where macros make sense.

It's a very common language to embed in video games as a modding and configuration tool.

Linked above is a subpage. The actual homepage at https://fennel-lang.org/ has code and even an integrated place to run it.

This isn't the landing page, which does show a code example prominently.