<br><div class="gmail_quote">On Dec 2, 2007 4:21 AM, Robert Virding <<a href="mailto:rvirding@gmail.com">rvirding@gmail.com</a>> wrote:<br><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">
<br><div><div>> I mean I have to sensibly be able to handle the case where someone writes (cons a mod:fun). What does this mean?
</div></div></blockquote><div> </div><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"><div><div>> - 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 :-) 
</div></div></blockquote><div> </div><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"><div><div>> 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 ... )
<br></div></div></blockquote><div><br>IMHO, the issues above arise from the goal being unclear: is it a lispy syntax for erlang or is it a lisp in erlang? <br><br>If it's a lispy syntax, IMO a prefix<->infix transformer can handle a lot of cases (below uses vector for tuples):
<br><br><div style="margin-left: 40px;">%% Erlang => ErlangInLisp <br>A + 1, => (+ A 1)<br>A = 5. => (= A 5).<br>[foo | bar] => (| foo bar) <br>Pid ! Data => (! Pid Data) <br>

A = {foo, bar}. => (= A #(foo bar)) %% or (= A {foo bar}) (either works fine, but vector version appears more uniform and in spirit of lisp) <br>fun(A) -> A + 1. => (lambda (A) (+ A 1)) %% I think fun is fine. <br>
case A of foo -> {foo}; bar -> {foo, bar} end. => (case A ((foo) bar) ((bar) #(foo bar))) <br>foo(1) -> 2; foo(abc) -> {foo, bar}. => (defun foo ((1) 2) ((abc) #(foo bar)))<br>mod:fun(foo) => (mod:fun foo) or ((: mod fun) foo)
<br>Mod:fun(foo) => (Mod:fun foo) or ((: Mod fun) foo) %% the second style is more uniform for both mod & Mod.<br>{ok, B} = mod:fun(). => (= #(ok B) (mod:fun))  or  (=  {ok B} ((: mod fun)))   <br><br>(I think "let" is something that'll be handy and can be introduced, as commas make the code more spaghetti-ish) 
<br><br></div>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. 
<br><br>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. 
<br><br>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.<br><br>If mod:fun(Args)  is writtten as (remote-call mod fun Args), then how to write apply/3? 
<br><br>Should we write apply(mod, fun, Args) as (apply (remote-call mod fun Args))??   Then it's apply/1. <br><br>Probably better to have remote-call take on the meaning of apply/3. I don't think all function calls should go through apply. 
<br><br>Cheers,<br>yc<br><br></div></div>