I don't have any use cases in mind right now, but this looks cool. You should try posting another Show HN.

I would love to see a stripped back ML-style language that targets lua, just something like ocaml's type system and exhaustive pattern match right on top would be all I need. There have been a few attempts but nothing I know of that got usably far and is maintained.

There might be a way to get standard ML to output lua or something but I'm not that familiar with it. I think it would be an incredible fit for a third backend for gleam, but they say they aren't adding any more beyond erlang and js.

Fennel is indeed nice and I rewrote my config in it too, but looked back ~2 years later and rewrote it again in Lua. I think Fennel for configuration is not justified and just adds complexity. Also the tools are not there: two existing language servers[1][2] can't compete with Sumneko's Lua language server[3] and they are fennel-exclusive and clueless about Lua code. I still like Fennel for writing more complicated code (my plugins: [4][5]) because of neat features like pattern matching and structural decomposition, both are surprisingly robust.

[1]: https://git.sr.ht/~xerool/fennel-ls/

[2]: https://github.com/rydesun/fennel-language-server

[3]: https://github.com/LuaLS/lua-language-server

[4]: https://gitlab.com/repetitivesin/16cm.nvim/-/tree/main

[5]: https://gitlab.com/repetitivesin/madol.nvim

Link to the macros: https://github.com/Grazfather/dotfiles/blob/master/nvim%2Ffn...

If only there was an editor which could act as an interpreter for Lisp directly ...

I like Janet a lot, and have been using it for small personal projects for about a year.

But it does come with some design decisions that I'm a bit ambivalent about and for which I haven't found a good explanation:

- No persistent data structures. I guess this has something to do with limitations of the GC?

- unhygienic macros combined with lack of namespaces. XOR those two choices would be fine, but the combination is janky

- Somewhat peculiar choices in syntax. It's neither Scheme, nor is it Clojure. # starts comments, ; is splice, @ marks literals as mutable...

I prefer Janet, but Fennel is great in places Lua is already supported, like in Löve2D.

https://git.sr.ht/~benthor/absolutely-minimal-love2d-fennel

I believe Fennel was originated by Phil Hagelberg (technomancy)

https://git.sr.ht/~technomancy/fennel-lang.org

Janet looks like is by Calvin Rose (bakpakin) https://github.com/janet-lang/janet/graphs/contributors

    % git remote -v
    origin https://git.sr.ht/~technomancy/fennel (fetch)
    origin https://git.sr.ht/~technomancy/fennel (push)

    % git log --reverse
    commit 9afe4338ed1816a759cb4b120f89e8f67159ce16
    Author: Calvin Rose <calsrose@gmail.com>
    Date:   Sun Aug 7 18:50:34 2016

        First commit.

    commit b62a24853e24662f76932a2a81bb77cc25704491
    Author: Calvin Rose <calsrose@gmail.com>
    Date:   Sun Aug 7 19:05:40 2016

        Add some examples.

    commit 5e3e0fe11e4f56007b3523e54d81d55280ef2204
    Author: Calvin Rose <calsrose@gmail.com>
    Date:   Tue Aug 9 08:27:43 2016

        Update README.md

Dammit, Janet! Ok, looks good. I'll need to look into it.

>by the same author

What? People are just creating new languages these days as if they were Javascript libraries?

Let's say I wanted to make my own programming language. What's the easiest way to prototype it in a way I can share it with the world? Are the programming language development toolkits that come with a tokenizer library and things like that? Should I write my own program to output machine code? Or maybe it's easier to just transpile to Javascript?

    32 = foo;

    pow(x, 2);
    pow(y, 2);
    sqrt() = result;

    {
        pow(x, 2);
        pow(y, 2);
        sqrt();
    } + 1;
    pow(2) = result;

Focusing on the runtime's parser is a red herring and I think a common error in lisp advocacy.

Even if I didn't the full power of a lisp macro system, it is an absolute joy to manipulate programs written in s-expressions. Being able to cut/copy/paste/jump-[forward/back] by sexpr is really convenient, and often done nowhere near as well in other languages. I think this is because until the invention of tree-sitter and LSPs (and the former isn't yet widely adopted in editor tech), most editors had regex-based syntax highlighting and some kind of ad-hoc "parser" for a language. This makes them less aware of the language the developer is editing, but was probably a pragmatic design decision by editor implementers: it's easier than writing a full parser and means the editor can still assist even if a program is syntactically ill-formed.

I do not understand the appeal of non-LISPy languages. I get that most people are used to reading it and that they are efficent, but I believe the developer (of the compiler in this case) should serve the convenience of the user, not the other way around.

Writing code like this is combersome and unnecessarily symbol heavy, and reading it isn't really nice as well.

I'd rather have the language add those extra parens into the parser than have me stare down these endless semi-colon, linebreaks or indentation. Parsing something Lisp-like is not that, hard, trust me, I've done it.

    (f x y)

    f(x, y);

    - it is used everywhere
    - carries very little information

    - in Janet nearly every line starts and ends with ( and ), which is just noise
    - in Janet there are several ))))
    - in Janet there is no special syntax for: function definition, variable definition, collections, statements
    - while Python is the opposite, it reads like a mix of English and Mathematics. Also it has special syntax for the ~5 things that you can do with the language, so you can just look at the Python code from far, don't read it, and you'll have a clue what's going on. It is also helpful when you search for something with your eyes. Also nested parentheses are different shaped parentheses, so you know which ones match.

The appeal can be seen with paredit-style [1] editor plugins. They give you the power of working on trees rather than text. When you master the paredit way of editing you’ll wish you could do that with every language.

[1] https://paredit.org/

I personally find lisp-y syntax to be pleasant to write, and to generally be straightforward and easy to read. It's interesting to hear you have the opposite opinion, though.

Try defining data in C. Try extracting data from that data you've defined in C.

If you can understand the appeal of having JSON in JavaScript, you can understand some of the appeal of Lisp.

> I’d rather have the language …

check out Lean 4 then. Its syntax system is based on Racket but —instead of parens— implements stuff like [JSX syntax](https://github.com/leanprover-community/ProofWidgets4/blob/d...) and a [maze](https://github.com/dwrensha/lean4-maze)

Most Lisp-y language have multiple parsers. The frontend may be that one, or it might be another. Racket has hundreds of frontends [2], Scheme has Wisp [0], and so on.

The ideal part of it comes down to the language being able to manipulate itself. Make the tokens an array, that you can shift, inject and/or mould into what you need.

That being said, that power isn't isolated to just Lisp-y. A few stack languages have it, like Forth, or to plug myself [1]. However, stack languages are a bit harder to optimise.

It isn't that they don't want a complicated parser. It's that you want to be able to easily modify that parser as its running, without hitting TeX levels of performance slowdowns.

[0] https://srfi.schemers.org/srfi-119/srfi-119.html

[1] https://git.sr.ht/~shakna/jstack

[2] https://doi.org/10.1145/3580417

The unmatched beauty of the Lisp is the elegance of writing code generators (macros).

Code is list and main structure is list. This is genius.

i have never used a lisp, but i’d assume due to its focus on macros, you are alternately the developer of a compiler and the user of that compiler. so making it easy on the compiler dev makes it easy on you.

Consider the following LISP function that performs a transformation of an MxN matrix:

(defun transpose (matrix) (apply #'mapcar #'list matrix))

Based on my own experience I think I can say that It isn't until one has acquired a reasonable amount of experience with the language that they can fully appreciate its power.

Are you interested in learning the appeal?

The first thing that comes to mind is macros.

I tried fennel for a game jam and honestly was pretty disappointed. The way lisp languages are pitched here, I thought I was in for a mind opening experience, but instead the end experience was pretty much identical to lua in ever meaningful way, the only differences felt surface level (I.e. using closures, and parentheses).

I'm forever indebt to lisp for giving JS it's saving graces (closures and FN as first class citizens), but I think we some honestly on what the end experience really is.

And yet people write a ton of XML, JSON or YAML by hand.

> Fennel's approach of compiling to Lua while maintaining meta-programming capabilities is elegant.

Yeah, it is very nice to work with.

The only tiny "complaint" I have is that it doesn't compile to pure Lua, but instead assumes you'll be running it together with Lua's libraries.

I say this because, for me, the places where I'd like to use Fennel have a lot of overlap with the places where I'd like to use Lua without loading any of the provided libraries (e.g. embedding Lua into other software, instead of using it standalone).

Another spot it's great for is in legacy lua programs that you inherit from who knows where, which in my experience is a lot of the live lua out there. It hooks into the module loader system so you can just freely mix functions and tables between the two.

I've been working on something along those lines in eli:

https://github.com/codr7/eli?tab=readme-ov-file#type-checkin...

I did find this, though it seems runime only: https://github.com/dokutan/typed-fennel

Maybe a static system can be built upon it.

it's kinda funny that whole noise about parenthesis. For a experienced Lisper parenthesis are so meaningless that can be ignored by reading good indented code, however... for a newbie, the amount of parenthesis can be a real nightmare. All that can just be properly solved by using a decent editor that support good parenthesis edition... like emacs. Truly funny. I've been on this community for more than 10 years and always the same thing.

I'd guess a major reason is that Java is statically typed, and Lua/Fennel are dynamic; making it easier to reuse any existing libraries.

JVM has no notion of a function, only of a method! You don't have something to piggy-back on. Java stdlib from 15 years ago (to say nothing of 25) is a realm of heavy OOP and mutability everywhere, something you may not want to adapt your Lisp code to.

I get the impression that Fennel is intended as a different/better interface for Lua.

In contrast, Clojure is intended as the language Rich Hickey wanted for writing the sort of applications he wrote, and the JVM happened to be a powerful (and already existing) platform that was suitable for doing that.

Clojure

I'm not sure if this was the up front reasoning but a lot of lua code is run in situations where you don't have full control over the runtime or distribution method.

So anything that requires C libs would automatically rule out fennel for a lot of projects that are essentially using someone's lua api as the target platform. Roblox, mud client scripting, openresty, that sort of thing.

And these environments usually have so much added to them, pcre, stdlib extensions, class systems etc fennel works best not making any assumptions about any of that. It's just straight up the lua semantics, and so anywhere lua works it works. I've used it a lot and originally recoiled from this decision but now I think it is genius.

> Not to detract from the language or anything I have found many programming languages justification to just not have an elevator pitch and I have a hard time understanding why this is the case.

But they do have one, that you just copied?