I was starting to get the feeling that Fennel’s functional style was at odds with the imperative Lua that it was acting as a thin wrapper on top of. so I’ve been learning Scheme lately instead, because Lisps are still interesting to me but I was starting to think that maybe Fennel was giving me a bad impression of what a Lisp can be

unfortunately Scheme has problems that I would consider much worse than Fennel, and those are:

a lot of its functions have strange legacy behavior and there are often multiple ways to do the same things, some of which have footguns that you have to memorize. for example just look at how complicated a simple equality check is in this language

its “documentation” is also its standard, which is written in very hard-to-understand academic-speak

since Scheme is a standard for a language and not a language per se, its ecosystem is fragmented between a bunch of different interpreters and compilers which have subtly different behavior from each other - some (but not all) of which include extra libraries on top of the standard library. so I really wonder how portable Scheme code is even between these different interpreters/compilers, let alone between different operating systems

the Scheme interpreter that I’m using, called CHICKEN, has a really bad REPL that can’t even handle me using the arrow keys. I was trying to find a better REPL but searching for “Scheme REPL” and “Scheme CHICKEN REPL” gives no useful results

I wonder if there’s a modern #Lisp that doesn’t have these problems, and also ideally has good tooling (like a good LSP or whatever the Lisp equivalent of an LSP is). I’ve deliberately avoided learning Common Lisp because I get the feeling that it’s going to have even more chaotic legacy behavior, footguns, etc. which I find very ugly in a programming language

@kasdeya FWIW, you're probably not going to escape legacy footguns in Lisp. Languages rarely stick around for 40+ years without developing some. As for the REPL, if you want a good one, you'll probably want something like geiser for scheme or SLIME for common lisp. They're both enhanced REPLs that integrate directly with Emacs for a pretty nice dev environment. If you're against emacs then you're best bet is probably rlwrap. It wraps whatever program you give it with GNU readline

@splatt9990 ugh, that sucks about the footguns. I feel like it wouldn’t be that hard to make a modern minimal Lisp from the ground up. which, I guess is kinda what Fennel is

also thanks for the info about REPLs! Emacs intimidates me a lot - I’ve already learned Vim and I know how hard that was lol, so I don’t know if I want to learn a second arcane editor :P but I might give rlwrap a try tbh

@kasdeya the closest thing to that's probably Clojure but it also means dragging the JVM with you.

For Vim, I *think* there's a version of SLIME for it creatively called VLIME, but I'm not sure if there's an equivalent for geiser.

re: the original issue with the difference in equality predicates, while there *is* 5-6 different equality predicates in scheme, you can pretty much always just use equal?. It just won't be as efficient as it could be.

@kasdeya you are looking for Racket.

@kasdeya preeeeeeeettty sure you want Janet

@kasdeya also i found that if you just wanna get stuff done in lisp, either clojure or common lisp will be your best bet

@valorzard ooh from a cursory look at Janet’s website, I think I might really like it. thanks for mentioning it!