[erlang-questions] ANNOUNCE - erl2 - a new dialect of erlang

Jakob Praher <>
Sun Feb 26 23:46:07 CET 2012


Hi Joe,

thanks for posting this, it made me think. IMHO it all boils down to a
syntactic issue: The ambiguity of the squence  "," operator. Otherwise I
see nothing completely wrong in interpreting a function form as an
expression that when evaluated introduce a function symbol of the
respecting arity in the current lexical scope and bind it to the
function object, e.g:
> f(X) -> X*X.
much like in your version
> def f(X) -> X*X end.

Clearly nested functions written like this fail:

myfun(X) ->
    f2(X) -> Y= 2, X + Y,
                          ^        ^   
    f2(X)    
    .

I think one could reuse the fun expression much like named funs but use
function symbols instead of variables names as in EEP-37.

myfun(X) ->
    fun f2(X) -> Y = 2, X + Y end,
    f2(X)    
    .

To summarize:
Instead of "def f(X) -> X * X end." I would write "fun f(X) -> X * X end."
I do not have the desire to write "def f = fun (X) -> X * X end."

A module could be also interpreted as a function that evaluates to a
tuple of function objects.
Regarding compilaton: I would understand that a module function is
compiled to an object file, if exported. Nested functions can only be
lexically accessed via their current lexical scope where they are
introduced in (and can be passed as values).

Cheers, and just my 2cents,
Jakob

Am 26.02.12 17:58, schrieb Joe Armstrong:
> From the README
>
> Announce
>
> Erl2 - a program generator for a new dialect of erlang
>
> Download from: https://github.com/joearms/erl2
>
> Please note: This is a prototype and is not of production quality (but
> it seems to work :-)
>
> Rational
>
> There are two types of thing in Erlang. Forms and Expressions
> and the two don't mix.
>
> The shell is an expression evaluator. The shell reads an expression
> evaluates it and prints the result.
>
> A module is a sequence of forms. The compiler takes a sequence of forms
> and compiles this into an object file.
>
> You can't put forms in shell because they are not expressions. And you
> can't put expressions in a module because they are not forms.
>
> This is a mess - in many other languages the input to the shell
> is the same as the input to the compiler - but not in Erlang.
>
> There is a fix to this. "All" you have to to is define a form to be an
> expression.
> This needs a small syntactic change to the language.
>
> Suppose we add a new syntactic form:
>
>     def fac = fun(0) -> 1; fun(N) -> N*fac(N-1) end.
>
> But we define this to be an expression with a side effect. It's value
> can be anything we like (say true). But it has a side effect. The side effect
> is to define the factorial function.
>
> With this change we could write (in the shell):
>
>    > def fac = fun(0) -> 1; fun(N) -> N*fac(N-1) end.
>    true.
>    > fac(5).
>    120
>
> With this and a few other changes the shell, modules, and escript become
> more or less idential.
>
> To test this I have modified the erlang grammar, and the evaluator
> I have also added letrec's and a fixed a few other small things
> that annoyed me.
>
> Here is a complete example - the comments are terse but hopefully the
> example should
> be self-explanatory ...
>
> %% This is an erl2 script
>
>> cat test.erl2
> %% hello world
>
> def hello() -> io:format("Hello world~n") end.
> hello().
>
> def test(N) -> io:format("Passing test ~p~n",[N]) end.
> def print(X) -> io:format("~p~n", [X]) end.
>
> test(1).
>
> print("factorial defined as a fun").
>
> def fac = fun(0) -> 1; (N) -> N*fac(N-1) end.
>
> print("Unit test of factorial").
>
> 120 = fac(5).
>
> print("Print a large factorial").
>
> print(fac(50)).
> test(3).
>
> print("define factorial using a fun").
>
> def fac1 = fun(0) -> 1;(N) -> N*fac1(N-1) end.
> print(fac1(50)).
>
> test(4).
>
> beginFunc f1/1 end.
>   %% f1 is a local fucntion - that is in the export list
>   %% so it will be exported
>
>   def f1(X) -> {f1,X} end.
>
>   {f1,123} = f1(123).
>
>   shell:test(5).      %% test(N) would mean in the local scope
>                       %% so we have to call this shell:test()
>
>   %% define a local function
>
>   def local(X) -> {local, X} end.
>   {local,222} = local(222).
>   shell:test(7).
>
> endFunc.
>
> %% Test that I can call the exported function
>
> {f1, a} = f1(a).
> test(8).
>
> %% test that calling the local function will fail
>
> {'EXIT', _} = (catch local(222)).
> test(9).
>
> %% Now make two functions both using the
> %% same auxilliary functions to test name hiding is correct
> %% BOTH of these use the same auxilliary function
>
> beginFunc f2/1 end.
>  def f2(X) -> foo(X) end.
>  def foo(X) -> {f2foo, X} end.     %% foo is not exported
> endFunc.
>
> beginFunc f3/1 end.
>  def foo(X) -> {f3foo, X} end.    %% foo is not exported
>  def f3(X) -> foo(X) end.
> endFunc.
>
> {f2foo,a} = f2(a).	
> {f3foo,a} = f3(a).
> test(10).
>
> %% add unit tests inside a function definition
>
> beginFunc f4/1 end.
>  def foo(X,Y) -> {f3foo, X+Y} end.    %% foo is not exported
>  {f3foo,5} = foo(2,3).
>  def f3(X) -> foo(1,X) end.
>  {f3foo,6} = f3(5).
> endFunc.
>
> test(11).
>
> print("Modules").
>
> beginMod mod1.
>
> defExports a/1 b/2 c/3 end.  %% ignored for now
>
>  def test(N) -> io:format("Passing local test in mod1:~p~n",[N]) end.
>
>  def a() -> {mod1,a} end.
>  {mod1, a} = a().
>  shell:test(12).
>
>  def a(X) -> {mod1,a,X} end.
>  {mod1, a, 12} = a(12).
>
>  shell:test(13).
>  test(14).
>
> endMod mod1.
>
> print("Testing that we can call functions in a module from outside").
>
> {mod1, a, 12} = mod1:a(12).	
> test(15).
>
> {'EXIT', _} = (catch mod1:b(12)).
> test(16).
>
> %% Mod with private functions
>
> beginMod mod2.
>
> defExports a/1 b/2 c/3 end.  %% ignored for now
>
>  def test(N) -> io:format("Passing local test ~p in mod2~n",[N]) end.
>  test(17).
>
>  beginFunc a/1 end.
>     def a(X) -> b(X) end.
>     def b(X) -> {mod2,b,X} end.
>  endFunc.
>
>  test(18).
>
>  {mod2,b,123} = a(123).
>  test(19).
>
> endMod mod2.
>
> {mod2,b,123} = mod2:a(123).
> test(20).
>
> print("Meta programming ...").
>
> %% We can bind variable *OUTSIDE* a module and
> %% use them *inside* the module
>
> F25 = fac(25).
>
> beginMod mod3.
>  defExports a/1 end.  %% ignored for now
>
>  def a(N) -> F25 + N end.
>
> endMod mod3.
>
> print(mod3:a(10)).
>
> print("Just imagine what you could do with this ...").
>
> print("More fancy stuff").
>
> %% We can do unit tests *inside the module*
> %% If the unit tests fail - we crash and the module will not be generated
>
> beginMod mod4.
>
>  defExports fac/1 end.
>  def fac(0) -> 1; fac(N) -> N*fac(N-1) end.
>
>  %% unit tests
>  120 = fac(5).
>  shell:print("unit test worked").
>
> endMod mod4.
>
> test(21).
>
> print("Horray - everything worked dump the results into a file
>        which we can compile later").
>
> --------------------------------------------------------------------
>
> We can run this as follows:
>
> ./erl2 tests.erl2
> Hello world
> Passing test 1
> "factorial defined as a fun"
> "Unit test of factorial"
> "Print a large factorial"
> 30414093201713378043612608166064768844377641568960512000000000000
> Passing test 3
> "define factorial using a fun"
> 30414093201713378043612608166064768844377641568960512000000000000
> Passing test 4
> Passing test 5
> Passing test 7
> Passing test 8
> ** undefined function:{local,1}
> Passing test 9
> Passing test 10
> Passing test 11
> "Modules"
> Passing test 12
> Passing test 13
> Passing local test in mod1:14
> "Testing that we can call functions in a module from outside"
> Passing test 15
> Passing test 16
> Passing local test 17 in mod2
> Passing local test 18 in mod2
> Passing local test 19 in mod2
> Passing test 20
> "Meta programming ..."
> 15511210043330985984000010
> "Just imagine what you could do with this ..."
> "More fancy stuff"
> "unit test worked"
> Passing test 21
> "Horray - everything worked dump the results into a file\n       which
> we can compile later"
> Created:"all.gen"
> Success
>
> Note1: The output is in all.gen
>        This contains sufficient information to build all the modules
>        defined in the script - or they can be built into a single module
>
> Note2: If unit tests fail then no code is generated.
>
>        This is rather nice - the compiler will not compile a file
>        unless it is passes the unit tests.
>
>        Normally we do this:
>
>           1) compile
>           2) test
>
>         Now we do this:
>
>           1) test
>           2) compile
>           3) nothing - don't need to do the unit tests -
>
> Note3: Erl2 has no macros - they are not necessary
>        the section called metaprogramming above explains this
>
> Have fun ...
>
> (Ps if anybody want to compile all.gen - please feel free - I'm a bit
> busy this week)
>
> /Joe
> _______________________________________________
> erlang-questions mailing list
> 
> http://erlang.org/mailman/listinfo/erlang-questions


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://erlang.org/pipermail/erlang-questions/attachments/20120226/4e6717cd/attachment.html>


More information about the erlang-questions mailing list