I think it would be nice to see some comparison to Clojure for example which is a JVM-integrated lisp-1. I have for example Elixir on my radar for a while but I'm very interested in seeing more lisp dialects running on popular VM implementations. My point is that I don't know how to compare this to Clojure (in my case). What advantages does it have and why should I use it?
I am a fan of clojure. I'm interested in LFE, but I've been focussing on learning Haskell lately, and don't want to switch gears yet.
The big thing that I miss in clojure are the data structures, and the ease of use of those data structures. Specifically vectors and maps. These exist all over the place, but no where (in my experience) are they as pain-free as clojure.
That combined with their immutability (yet easy to transform) is a really significant win for productivity.
As I've looked for other languages to learn, those sorts of easy to use and highly productive datastructures has been a top criteria.
Haskell has them, but I wouldn't put them on the easy to use list yet. However I'm still learning, and it might just come down to familiarity.
Chicken Scheme has them as an egg, but the syntax makes them far more encumbering than clojure.
If LFE has the same unencumbered immutable datastructures for maps and vectors, well, that would be exciting to me.
> Specifically vectors and maps. These exist all over the place, but no where (in my experience) are they as pain-free as clojure.
You don't use vectors very much on the BEAM in general, so I wouldn't consider this very important. Maps are more popular, but have a complicated relationship with records and records have, due to historical reasons, not seen much light on the BEAM in general until lately.
Tuples, which you could use as vectors, sort of, can be written as follows:
(tuple 'hey 'ho "let's go") <-> #(hey ho "let's go")
Tuples are infinitely more important than maps on the BEAM and so they deserve special syntax.
I think insisting that everything should be like Clojure is a great way to not really see anything different. While I understand that your idea is that "everything else should see what's so great about Clojure", maybe you could take that to heart as well.
Edit, addition: I wonder what the stats on posts starting with "I'm/As a Clojure fan..." are. If someone is an Archlinux user, a vegan, a crossfitter and a Clojure user, which do they tell you first?
I prefaced with clojure fan to give context for my post. As a clojure fan, my point of view is going to be from a clojurist. It's a clue as to how to remove bias.
I don't think everything should be like clojure, I just think clojure gets datastructures right in ways that I haven't seen in other languages. I don't think I insisted on everything, or anything, being like clojure.
Right now my dream language would be mostly haskell with clojure maps. Next year it could be something different.
"Maps are more popular, but have a complicated relationship with records and maps have, due to historical reasons, not seen much light on the BEAM in general until lately."
The correction is that maps are the rarer thing, whereas records are more common, due to their lightweight implementation (tuples).
> The big thing that I miss in clojure are the data structures, and the ease of use of those data structures. Specifically vectors and maps. These exist all over the place, but no where (in my experience) are they as pain-free as clojure.
I'm not sure I understand. Why do you miss them when you have them in Clojure? Is it a typo and you meant to say LFE?
By the way one of my biggest productivity boost for me is the hot code swap which works in Clojure seamlessly. In java you can't do this wihtout JRebel for example. What is the case with LFE?
I think (s)he meant that they are a feature in clojure that is missed in LFE. The sentence construction is a bit off, but I read it as "[I miss](in LFE)[in clojure are the data structures]". That is, the "in clojure" is the data structures, not where it is missed.
