[erlang-questions] Lisp syntax for Erlang

YC yinso.chen@REDACTED
Tue Dec 4 03:51:43 CET 2007

On Dec 2, 2007 4:21 AM, Robert Virding <rvirding@REDACTED> wrote:

> > I mean I have to sensibly be able to handle the case where someone
> writes (cons a mod:fun). What does this mean?

> > - Seeing this is based on Erlang I can't introduce any new data types.
> So with the argument above I can't have variables as a separate > data type,
> separate from symbols/atoms. So Mod:fun will mean the same as mod:fun but
> with a different name. Now that was clear :-)

> > So that is why I have no better suggestion for the moment to the general
> function (remote-call <mod> <fun> ... ) and its short hand > form the macro
> (: mod fun ... )

IMHO, the issues above arise from the goal being unclear: is it a lispy
syntax for erlang or is it a lisp in erlang?

If it's a lispy syntax, IMO a prefix<->infix transformer can handle a lot of
cases (below uses vector for tuples):

%% Erlang => ErlangInLisp
A + 1, => (+ A 1)
A = 5. => (= A 5).
[foo | bar] => (| foo bar)
Pid ! Data => (! Pid Data)
A = {foo, bar}. => (= A #(foo bar)) %% or (= A {foo bar}) (either works
fine, but vector version appears more uniform and in spirit of lisp)
fun(A) -> A + 1. => (lambda (A) (+ A 1)) %% I think fun is fine.
case A of foo -> {foo}; bar -> {foo, bar} end. => (case A ((foo) bar) ((bar)
#(foo bar)))
foo(1) -> 2; foo(abc) -> {foo, bar}. => (defun foo ((1) 2) ((abc) #(foo
mod:fun(foo) => (mod:fun foo) or ((: mod fun) foo)
Mod:fun(foo) => (Mod:fun foo) or ((: Mod fun) foo) %% the second style is
more uniform for both mod & Mod.
{ok, B} = mod:fun(). => (= #(ok B) (mod:fun))  or  (=  {ok B} ((: mod

(I think "let" is something that'll be handy and can be introduced, as
commas make the code more spaghetti-ish)

And keep the rest of the erlang syntax such as Camel casing for variable,
pattern matching built-in default, bare words as atoms unless at the the
head of a list (or unless in special syntax such as case), etc.

If the goal is to write a lisp compiler, then either CL or Scheme has
already offered their definitions (of course you can invent your own too).
In CL mod:fun means calling the function fun in module mod, and in scheme it
simply is a symbol binding that can mean anything.  By default lisp doesn't
have pattern matching, but if you are introducing macro then you can of
course gain it back.

The issue with (remote-call) is that it's tedious.  Think of having to write
that for all function calls that don't live in the current module
namespace.  And it also takes on meaning of apply/3.

If mod:fun(Args)  is writtten as (remote-call mod fun Args), then how to
write apply/3?

Should we write apply(mod, fun, Args) as (apply (remote-call mod fun
Args))??  Then it's apply/1.

Probably better to have remote-call take on the meaning of apply/3. I don't
think all function calls should go through apply.

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://erlang.org/pipermail/erlang-questions/attachments/20071203/b09ea085/attachment.htm>

More information about the erlang-questions mailing list