efene programming language

have you ever wanted to learn a functional programming language but you were scared by the syntax?

then efene is for you!

why?

javascript/python like syntax
erlang power

fast! show me an example!

efene (hello.fn)

# classic hello world

hello = fn (Who) {
    io.format("hello ~s!~n", [Who])
}

@public
run = fn () {
    hello("world")
}

compile

    
    fnc hello.fn

run (call the run function from the hello module)

    
    fn hello run

ifene (hello.ifn)

# classic hello world

hello = fn (Who)
    io.format("hello ~s!~n", [Who])

@public
run = fn ()
    hello("world")

compile

    
    fnc hello.ifn

run (call the run function from the hello module)

    
    fn hello run

that was simple, a more complex one!

efene (demo.fn)

# if statement
compare = fn (A, B) {
    if A < B {
        lt
    }
    else if A > B {
        gt
    }
    else {
        eq
    }
}

# switch statement and multiline expressions
compare_to_string = fn (Result) {
    switch Result {
        case lt {
            "lower than"
        }
        case gt {
            "greater than"
        }
        case eq {
            "equal to"
        }
        else {
            "invalid value '" ++
                atom_to_list(Result) ++
                "'"
        }
    }
}

# multiple function definition and guards
compare_to_string_guards = fn (Result) when Result == lt {
    "lower than"
}
fn (Result) when Result == gt {
    "greater than"
}
fn (Result) when Result == eq {
    "equal to"
}
fn (Result) {
    "invalid value '" ++
        atom_to_list(Result) ++
        "'"
}

# try/catch expression and tuples
fail = fn (Fun) {
    try {
        Fun()
    }
    catch error Error {
        ("error", Error)
    }
    catch throw Throw {
        ("throw", Throw)
    }
    catch Type Desc {
        (atom_to_list(Type), Desc)
    }
}

# pattern match
do = fn (add, A, B) {
    A + B
}
fn (mul, A, B) {
    A * B
}
fn (div, _A, 0) {
    invalid_division
}
fn (div, A, B) {
    A / B
}

# main function, made public to access it outside the module
@public
run = fn () {
    # lambda functions
    Print = fn (Expr) { io.format("~p~n", [Expr]) }

    Print(compare(1, 2))
    Print(compare(2, 1))
    Print(compare(2, 2))

    Print(compare_to_string(lt))
    Print(compare_to_string(gt))
    Print(compare_to_string(eq))
    Print(compare_to_string(this_is_an_invalid_value))

    Print(compare_to_string_guards(lt))
    Print(compare_to_string_guards(gt))
    Print(compare_to_string_guards(eq))
    Print(compare_to_string_guards(this_is_an_invalid_value))

    # call fail with a function that will fail in different ways
    Print(fail(fn () { throw("throw here") }))
    Print(fail(fn () { erlang.error("error here") }))
    Print(fail(fn () { exit("exit here") }))

    Print(do(add, 10, 2))
    Print(do(mul, 10, 2))
    Print(do(div, 10, 2))
    Print(do(div, 1, 0))
}

compile

    
    fnc demo.fn

run

    
    fn demo run

ifene (demo.ifn)

# a demo that shows different expressions

# if statement
compare = fn (A, B)
    if A < B
        lt
    else if A > B
        gt
    else
        eq

# switch statement and multiline expressions
compare_to_string = fn (Result)
    switch Result
        case lt
            "lower than"
        case gt
            "greater than"
        case eq
            "equal to"
        else
            "invalid value '" ++
                atom_to_list(Result) ++
                "'"

# multiple function definition and guards
compare_to_string_guards = fn (Result) when Result == lt
    "lower than"
fn (Result) when Result == gt
    "greater than"
fn (Result) when Result == eq
    "equal to"
fn (Result)
    "invalid value '" ++
        atom_to_list(Result) ++
        "'"

# try/catch expression and tuples
fail = fn (Fun)
    try
        Fun()
    catch error Error
        ("error", Error)
    catch throw Throw
        ("throw", Throw)
    catch Type Desc
        (atom_to_list(Type), Desc)

# pattern match
do = fn (add, A, B)
    A + B
fn (mul, A, B)
    A * B
fn (div, _A, 0)
    invalid_division
fn (div, A, B)
    A / B

# main function, made public to access it outside the module
@public
run = fn ()
    # lambda functions
    Print = fn (Expr) { io.format("~p~n", [Expr]) }

    Print(compare(1, 2))
    Print(compare(2, 1))
    Print(compare(2, 2))

    Print(compare_to_string(lt))
    Print(compare_to_string(gt))
    Print(compare_to_string(eq))
    Print(compare_to_string(this_is_an_invalid_value))

    Print(compare_to_string_guards(lt))
    Print(compare_to_string_guards(gt))
    Print(compare_to_string_guards(eq))
    Print(compare_to_string_guards(this_is_an_invalid_value))

    # call fail with a function that will fail in different ways
    Print(fail(fn () { throw("throw here") }))
    Print(fail(fn () { erlang.error("error here") }))
    Print(fail(fn () { exit("exit here") }))

    Print(do(add, 10, 2))
    Print(do(mul, 10, 2))
    Print(do(div, 10, 2))
    Print(do(div, 1, 0))

compile

    
    fnc demo.ifn

run

    
    fn demo run

all erlang libraries available
bytecode compatible (can use erlang modules from efene and vice-versa)
translate efene sourcecode to erlang
braces as block delimiters like C/C++/C#/Java/Javascript
alternative indent as block delimiter through ifene (idented efene) for python fans

no multiple delimiters (, . ; and no delimiter) in different situations

unified syntax to define functions and lambdas
arithmetic operators like C/C++/C#/Java/Javascript
- + - * / % | & ^ ~ (instead of + - * / rem bor band bxor bnot)
comparison operators like C/C++/C#/Java/Javascript
- == != === !== < <= > >= (instead of == /= =:= =/= < =< > >=)
python like boolean operators
- and or not (instead of andalso, orelse, not)
python-like lists and tuples
- [] and () (instead of [] and {})
python-like lists comprehensions
- [Number for Number in Numbers if Number % 2 == 0] (instead of [Number || Number <- Numbers, Number rem 2 == 0])
java-like try/catch/finally
and more to come..

here are available some examples that you can get with efene

to download and run this examples you need to run the following commands

# clone the repository with the latest code
git clone git://github.com/marianoguerra/efene.git

# go to the source directory
cd efene/src/

# build the binaries
./build.sh

# go to the examples folder
cd ../examples/

# compile an example 
../bin/fnc test.fn
# or
../bin/fnc test.ifn

# run the example
../bin/fn test run

you can compile and run them one by one with the following commands

cd efene/examples

# fnc is the efene compiler
# numbers.fn the name of the file to compile

../bin/fnc numbers.fn

# fn is the program that executes efene programs
# numbers is the module that we want to run
# run is the method we want to call inside the numbers module

../bin/fn numbers run

see examples at github

Download

just go to github and clone it or download the latest snapshot

Participate

a mailing list is available at librelist just send a mail to efene@librelist.com to subscribe

as first mail you may send a hello world program in efene and present yourself by saying your name, where you are, how did you heard about efene and anything else you would like to say.