Namby Pamby Magicians


    0.0.4 • Public • Published


    Aletheia is an experimental compiled-to-javascript programming language.

    The goals of aletheia are to:
    1. encourage safety
    2. be concise
    3. interop with javascript seamlessly

    For 1 and 2, Aletheia's philosopy is to "make correct things easy, but make incorrect things hard". For example, immutable variables require no prefix to declare them. However, mutable variables require a prefix for both declaration and mutation.

    Language features:
    • variables are immutable and local by default
    • extremely concise lambda syntax encourages a functional programming style
    • extensible control-flow structures
    Aletheia is quite alpha.

    We're still missing some basic things, which we intend to implement in the future:

    • for loops (but you could write your own!)
    • compile time enforcement of several errors
    • returning from a function inside an if-block
    • macros
    • types



    Const variables by default

    a = 5
    if true [
        mutate a = 6  // illegal! mutating a const variable
    >> SyntaxError: ALC: Mutating `a`, which has modifier `const` is not permitted. Declare with `mutable` to allow mutation.

    Mutable variables may be declared with mutable

    mutable a = 5
    if true [
        mutate a = 6  // compiles correctly

    Shadowing is an error

    mutable a = 5
    if true [
        a = 6  // illegal! declaring a new variable
    >> SyntaxError: ALC: Shadowing `a` is not permitted. Use `mutate` to mutate.


    function calls

    console.log "arg1" "arg2"

    function declarations

    f = [ n | ret (n + 1) ]
    console.log (f 4)  // prints 5

    Control flow

    If statements are function calls

    if ((1 + 1) == 2) [
        console.log "correct!"

    While loops are function calls

    mutable i = 0
    while [ret (i < 10)] [  // this is not the final syntax
        console.log i
        mutate i = i + 1

    Cross-functional examples


    fib = [ n |
        mutable a = 1
        mutable b = 0
        mutable i = 0
        while [ret (i < n)] [
            old_b = b
            mutate b = a + b
            mutate a = old_b
            mutate i = i + 1
        ret b

    Setup / Installation

    Aletheia is quite unstable currently, but if you'd like to play with it (which I pretty much don't recommend at this point), the setup instructions are:

    To install the current semistable library version of the compiler

    npm install -g aletheia
    alc <> <output_file.js>

    To install the current (unstable) library version of the compiler

    npm install -g git://
    alc <> <output_file.js>

    To run the library compiler from the git repo:

    git clone
    ./aletheia/lib/aletheia/alc <source .al input file> <destination .js output file>

    To create the latest bootstrapped compiler:

    git clone
    cd aletheia/
    npm install
    make build
    make test  # to run the tests
    ./build/alc [source .al input file] [destination .js output file]  # our created compiler




    npm i aletheia

    DownloadsWeekly Downloads






    Last publish


    • ariabuckles