Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Lisp Flavoured Erlang 1.0 released after 8 years of development

github.com

Post reply on HN
Print view View original

71–80 of 96 posts

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#71

Post by rvirding »

namelezz wrote: post #3

> A proper Lisp-2, based on the features and limitations of the Erlang VM What are limitations?

Some limitations (?): are no global data; no shared data; all data is immutable; the modules are different from CL packages; functions can't have variable number of arguments[]. It does however have support for decent pattern matching and full access to all of Erlang's concurrency, fault-tolerance and scalability properties. Plus real macros as god intended.

[] The macro handling can go part way to hide this.

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#72

Post by rvirding »

namelezz wrote: post #3

> A proper Lisp-2, based on the features and limitations of the Erlang VM What are limitations?

Some limitations (?): are no global data; no shared data; all data is immutable; the modules are different from CL packages; functions can't have variable number of arguments[]. It does however have support for decent pattern matching and full access to all of Erlang's concurrency, fault-tolerance and scalability properties. Plus real macros as god intended.

[] The macro handling can go part way to hide this.

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#73

Post by rvirding »

kazinator wrote: post #48
seiji wrote: post #39

Earlier quoted context omitted.

In Erlang you need to have explicit number of arguments and need to explicitly implement them. Or, you know, just use lists as parameters. That's the standard Erlang pattern for unknown parameters lengths (e.g. io:format("debug ~s because ~p~n", [SomeString, SomeType]))

Firstly, this still requires a mechanism which underlies the [ ... ] notation for evaluating a sequence of any number of expressions and constructing a list. In Lisp dialects, that is done by a variadic function: (list 1 2 3 4 ...) Of course, if we don't need to indirect on this function, we could implement it as a macro (supposing further that we have variadic macros for compile time, but not variadic functions for…

LFE macros can have variable number of arguments. The compiler does very little in helping with this as there are in principle no inter-module dependencies. This is a requirement of the dynamic code handling which allows you to reload any module at any time without any requirements on the contents. All checking is done at run-time. This is a basic property of the Erlang system and to make something which is fully compatible you have to follow this.

One way to have made LFE fully variadic in its functions would have been to have made each function only take one argument which is a list of the arguments in the call. This would have been easy to do but made it very difficult to interface LFE with the rest of the Erlang system in a clean way.

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#74

Post by rvirding »

StreamBright wrote: post #35
philjackson wrote: post #32

I'd love to see a comparison with Clojure, anyone know of such a thing yet?

You can answer this from many angle: - Clojure vs LFE - JVM vs BEAM - Lisp-1 vs Lisp-2 Etc, if you are interested only in the syntax differences, there is not much difference there (there are obviously some though!). I think generally speaking Erlang has fewer libraries than Java so that is a big difference in my opinion.

One major difference between the JVM and the BEAM is the type of application they target. The BEAM is designed to implement Erlang so it supports everything necessary to run Erlang at the base level. It is concurrency, fault tolerance and scalability from the very bottom all the way to the top.

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#76

Post by vvanders »

rvirding wrote: post #66
vvanders wrote: post #54

Earlier quoted context omitted.

Shame about luerl not supporting __metatable properly. That's half of why Lua is awesome. Still a massive achievement, awesome stuff.

Main issue is that luerl does support metatables. That caveat was written ago and I can't remember what it was I didn't support then. But as I said now it works.

Kudos! That's really awesome then.

I've got a lot of love for Lua(works great in embedded spaces, we use to do game logic in ~400kb block on a PSP with ~8mb of RAM).

Metatables are such an great way of exposing composability without putting a lot of restrictions on how the language works.

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#77

Post by piokuc »

rvirding wrote: post #75

I do want to point out that LFE has been release ready and of production quality for a long time but I tend to suffer from a "Jag ska bara"* syndrome which has delayed things. :-) * I am just going to ...

Thank you so much for this wonderful stuff!

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#78

Post by yurrriq »

jb1991 wrote: post #14

Virding's YouTube presentation at a Clojure conference about this new lisp says this in the caption: >LFE (Lisp Flavoured Erlang) has been designed to run efficiently on the Erlang VM and at the same time be a "real lisp" providing Lisp's good bits. It also knocks Clojure a bit. What do you all think are the "good bits" of lisp that Clojure lacks?

Tail recursion optimization, for one. Clojure makes up for it with recur though, so in practice, it's not that big of a deal.

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#79

Post by yurrriq »

technomancy wrote: post #45
StreamBright wrote: post #23

Earlier quoted context omitted.

This is a feature to me more like a limitation. I do not like optional arguments &rest style. In Erlang you need to have explicit number of arguments and need to explicitly implement them. I really like that. Keep in mind that default values are trivial to implement when the smaller arity function calls the higher arity one with added values. Or you can call in yourself to the higher arity function and specify the pa…

I feel like it's OK not having rest args if you leave them out in order to support currying, but leaving both out seems really weird for a language that's trying to be functional.

We can have rest args in LFE via something like

    (defmacro foo args
      (do 'something (with args)))
where

    (and (>= (length args) 0)
         (=
Note the lack of parentheses around args in the defmacro form.

Edit: Oops, Robert mentioned this, too.

Re: Lisp Flavoured Erlang 1.0 released after 8 years of development

#80

Post by lispm »

oubiwann wrote: post #60
lispm wrote: post #16

Earlier quoted context omitted.

The Lisp renaissance started in December 1999 with SBCL being forked from CMUCL.

Agreed. Well, with the date, anyway ;-) (though I am an SBCL user) Somewhere around 2000 we saw the end of AI winter. This most likely owes something to the fairly impressive Lisp marketing that PG did. Within a few years, several new Lisp books came out, and a few years after that we saw what the other poster mentioned: but not Just Clojure, a plethora of Lisps. To mention just a few: Clojure, Liskell, and LFE (LFE…

My personal favorite date was June 2003. The release date of LispWorks 4.3.

https://groups.google.com/forum/#!msg/comp.lang.lisp/CZX6uGN...

Then LispWorks was fully ported to Mac OS X (incl. Cocoa-based GUI and IDE) and there was then a replacement for Macintosh Common Lisp, which was given up and not ported to OSX/x86/Cocoa.

Post reply on HN