Mariano Guerra

Erlang Basel Meetup

March 2016

• Mariano Guerra

• Argentina

• Stuttgart ~ 4 Years

• Erlang, Clojure, Javascript, Python, Scala, Java

• An Accident

  • A calculator that went wrong :)

• Influences from Python and Javascript

• The hipster language

  • language on the BEAM before it was cool

  • "efene, I'm sure you never heard of it"

{
    "string": "string",
    "integer": 4,
    "float": 12.3,
    "boolean": true,
    "list": [1, null,  "fourteen!"],
}

• Invalid JSON (see trailing comma ;)

• Valid efene

Variable
an_atom
`an atom`
()
(1,)
(1, 2)
'a binary string'
[cons :: list]
fn lists.map:2

Nope

#atom "I'm an atom"

#c "A"

#r.person {name: "bob", lastname: "sponge", age:29}

#i line

#i module

#m PI

#m AUTHOR(bob)

#b {
    Version:4,
    IHL:4,
    TypeOfService:8,
    TotalLength:16,
    Identification:16,
    FlagX:1,
    FlagD:1,
    FlagM:1,
    FragmentOffset:13,
    TTL:8,
    Protocol:8,
    HeaderCheckSum:16,
    SourceAddress:32,
    DestinationAddress:32,
    Rest: binary
}

#b {
    _: _,
    A: _,
    JustSize: 8,
    JustType: binary,
    E: {},
    _: {size: 8},
    _: {type: float},
    _: {sign: unsigned},
    _: {endianness: big},
    _: {unit: 8},
    B: {size: 8, type: float, sign: signed, endianness: little, unit: 16}
}

@export(hello/0, plus/2)

@record(foo) -> (a, b = 12, c = true, d = 12)

@type(f3) -> fun([boolean(), term()], integer())

@import(erlang, [phash2/1])

@on_load(fname/0)

@include("path/to/file.hrl")

• Erlang for me is data, functions, guards and pattern matching

• Pattern matching is pervasive in the language

  • case clauses, catch clauses, function clauses

case: <exprs>

case one: <exprs>

case one, two: <exprs>

case one, two when <guard>: <exprs>

else: <exprs>

fn my_function
  case error, Reason: Reason
  case exit, Reason: Reason
  else: other
end

fn
  case error, Reason: Reason
  case exit, Reason: Reason
  else: other
end

receive
  case error, Reason: Reason
  case exit, Reason: Reason
  else: other
end

try
    <exprs>
catch
  case error, Reason: Reason
  case exit, Reason: Reason
  else: other
end

match A:
  case error, Reason: Reason
  case exit, Reason: Reason
  else: other
end

There's no if in erlang, just standalone guards:

when  <cond>: <exprs>

else <cond>: <exprs>

else <cond>: <exprs>

else: <exprs>

for X in lists.seq(1, 10); when X % 2 is 0:
  X + 1
end

• trailing commas allowed everywhere

• ^_ "comments" an expression

• #_ "comments" a value

• threading value to functions

lists.seq(1, 10) ->>
    lists.filter(IsOdd) ->
    MyMap(Increment)

lists.map(R) <<- case X:
  X + 1
end

MapR(R) <- case X:
  X + 1
end

• Erlang macros can be used (dark magic)

• Compiles to BEAM bytecode and Erlang 1:1 equivalent source code

• dializer

• xref

• Any other erlang tool that works on erlang bytecode, core erlang or erlang AST

• There's none

• There are no efene specific tools

• No efene specific libraries

  • List of "blessed" Erlang libraries

  • No efene wrappers or efenization of Erlang libraries

• rebar3 (with a plugin), common test, cowboy, exometer, lager

• Documentation and rebar3 templates as part of core language development

• The language is finished

  • No new syntax unless erlang adds syntax

  • Or unless there's a bad corner case I didn't noticed

  • And since there's no stdlib...

  • Yeah, boring

• First beta should go out when I have time to improve docs and polish a few things

• Try it

• Read the docs, contribute improvements, blog about it

• Write syntax highligters and indent support for your text editor

Great, I can help you!

commit 1:

rebar3 new fn_escript name=otl

cd otl

rebar3 escriptize

./_build/default/bin/otl

Because reading absform is too much work :)

commit 2:

$ ./_build/default/bin/otl erl2ast examples/mymod.erl

{ok,[{attribute,1,file,{"examples/mymod.erl",1}},
     {attribute,1,module,mymod},
     {attribute,2,export,[{main,0}]},
     {function,4,main,0,[{clause,4,[],[],[{atom,4,true}]}]},
     {eof,5}]}

commit 3:

$ ./_build/default/bin/otl erl2ast2erl examples/mymod.erl

-file("examples/mymod.erl", 1).

-module(mymod).

-export([main/0]).

main() -> true.

commit 4:

$ ./_build/default/bin/otl erl2beam examples/mymod.erl .

{ok,[{module_name,mymod},{path,"./mymod.beam"}]}

$ erl

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:4:4] [async-threads:10]
[kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> mymod:main().
true
2> q().
ok

commit 5:

$ cat examples/trues.otl

true true true


$ ./_build/default/bin/otl lex examples/trues.otl

{ok,[{boolean,1,true},{boolean,1,true},{boolean,1,true}],2}

commit 6:

$ ./_build/default/bin/otl ast examples/trues.otl

{ok,[{atom,1,true},{atom,1,true},{atom,1,true}]}

commit 7:

$ ./_build/default/bin/otl mod examples/trues.otl mymod myfun

{ok,[{attribute,1,file,{"examples/trues.otl",1}},
     {attribute,1,module,mymod},
     {attribute,2,export,[{myfun,0}]},
     {function,3,myfun,0,
               [{clause,4,[],[],
                        [{atom,1,true},{atom,1,true},{atom,1,true}]}]}]}

commit 8:

$ ./_build/default/bin/otl beam examples/trues.otl . mymod myfun

{ok,[{module_name,mymod},{path,"./mymod.beam"}]}

commit 9:

$ ./_build/default/bin/otl erl examples/trues.otl mymod myfun

-file("examples/trues.otl", 1).
-module(mymod).
-export([myfun/0]).

myfun() -> true, true, true.

rebar3 efene compile --format=erl

commit 10:

$ ./_build/default/bin/otl eval examples/trues.otl

true

commit 11:

$ ./otl-shell
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:4:4] [async-threads:10] [kernel-poll:false]

otl shell (Ctrl+g and then q to quit, Ctrl+g for Job Control Mode)

>>> true
true
>>> true true
true
>>>
>>> false
error: {1,otl_lexer,{illegal,"f"}}
>>> ^G
User switch command
 --> q

commit 12:

$ ./otl-shell
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:4:4] [async-threads:10] [kernel-poll:false]

otl shell (Ctrl+g and then q to quit, Ctrl+g for Job Control Mode)

>>> 1
1
>>> 1 true
true
>>> 1 true 1111
1111
>>> ^G
User switch command
 --> q

$ ./_build/default/bin/otl erl examples/one_true_language.otl one_true language

-file("examples/one_true_language.otl", 1).

-module(one_true).

-export([language/0]).

language() -> 1, true.

We just created the one true language (TM)

gh:marianoguerra/otl to follow each step as a commit