
Lisp Flavoured Erlang - indatawetrust
http://lfe.io/
======
macintux
One of the particularly nice things about LFE is the team's commitment to
documentation. Duncan McGreggor has done a great job.

------
edem
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?

~~~
DigitalJack
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.

~~~
59nadir
> 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?

~~~
DigitalJack
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.

------
brudgers
Recent discussion:
[https://news.ycombinator.com/item?id=11302125](https://news.ycombinator.com/item?id=11302125)

------
i_s
As a Clojure fan, I tried using this, but I got the impression it has learned
next to nothing from Clojure, so I ended up going with Elixir instead.

Particularly:

\- No data structure literals (?) - (except e.g., '(1 2 3) for lists)

\- Manual module exports, instead of just having 2 versions of def

\- Other small syntactic annoyances, like plain parens everywhere, instead of
brackets in some cases like Clojure, and atoms (like keywords in clojure)
started with "'" rather than ":"

~~~
i_s
In general, it seems like the authors of Elixir were able to capture more of
the cool things about Clojure than LFE. Check out some of the top level
functions in Elixir:

    
    
      update_in
      put_in
      get_in
    

[http://elixir-
lang.org/docs/stable/elixir/Kernel.html#update...](http://elixir-
lang.org/docs/stable/elixir/Kernel.html#update_in/3)

These are basically right out of Clojure. It may seem like a small thing, but
consistent, well thought out functions like this makes working with immutable
data structures much easier.

~~~
junke
"update", "put" are already available in Erlang[0] and work with nested
records[1] if I understand correctly. Likewise, it seems that LFE has map-
update for the same use cases[2].

[0] [http://erlang.org/doc/man/maps.html](http://erlang.org/doc/man/maps.html)

[1]
[http://erlang.org/doc/reference_manual/records.html#id86378](http://erlang.org/doc/reference_manual/records.html#id86378)

[2]
[https://github.com/rvirding/lfe/blob/develop/doc/user_guide....](https://github.com/rvirding/lfe/blob/develop/doc/user_guide.txt)

------
izietto
I love the website!!!

------
amelius
That cup of coffee in the logo suggests they are compiling to the Java JVM. If
true, this makes me wonder why aren't they using Erlang itself as a target?

~~~
eggy
No, it is built right on top of Erlang for seamless integration, and of note
is that it was created by Robert Virding, one of the original creators of
Erlang along with Joe Armstrong.

LFE macros deliver true homoiconicity to Erlang. It is a Lisp 2, and supports
function and macro definitions at the REPL.

I prefer it to Elixir, because I prefer Lisp. Robert has also created a Lua
5.2 written in pure Erlang.

Evidently, Erlang's actors and BEAM VM were influenced by the JVM and Scala,
so I guess doing a JVM Erjang was in the cards. [1]

[1] [https://www.infoq.com/news/2011/04/erlang-copied-jvm-and-
sca...](https://www.infoq.com/news/2011/04/erlang-copied-jvm-and-scala)

~~~
pessimizer
_Erlang Copied Scala 's Actors & Erlang's VM is almost a Clone of the JVM_ \-
Apr 01, 2011

Erlang was released in 1986, Java in 1995, and Scala in 2004.

I wouldn't be surprised if LFE were older than Scala.

~~~
dozzie
According to Wikipedia, work on BEAM started in 1992. Still earlier than Java.

LFE appeared in 2008, so it's newer than Scala.

~~~
eggy
Erlang was released into the 'wild' in 1988, but it had a Prolog-based VM, or
JAM, Joe's Abstract Machine before the BEAM.[0]

The BEAM VM was being worked on in 1992 a year after work on Java in 1991.

[0]
[http://erlang.org/faq/implementations.html](http://erlang.org/faq/implementations.html)

~~~
dozzie
> The BEAM VM was being worked on in 1992 a year after work on Java in 1991.

You're right. What I meant by "still earlier than Java" is "still earlier than
first public Java version", so there was no possibility to borrow anything.

