What AEL compiles today

// Structs, fixed arrays, references and bounds-checked indexing,
// with checked arithmetic and the explicit wrapping/saturating modes.

struct Reading {
    sensor: i32,
    value: i64,
}

fn total(samples: &[i64; 4]) -> i64 {
    let mut sum: i64 = 0;
    let mut i: i64 = 0;
    while i < 4 {
        sum = sum + (*samples)[i];
        i = i + 1;
    }
    return sum;
}

fn main() -> i64 {
    let samples: [i64; 4] = [10, 20, 30, 40];
    let sum: i64 = total(&samples);
    print(sum);

    let reading: Reading = Reading(7, sum);
    print(reading.value);

    // Explicit modes are the only way to leave the checked default.
    let wrapped: i8 = wrapping_add(127, 1);
    let saturated: i8 = saturating_add(127, 1);
    print(wrapped == -128);
    print(saturated == 127);

    return 0;
}

ael check checked.ael --tier core
ael compile checked.ael -o checked.aelir --target linux-x86_64 --no-metrics
ael build checked.aelir -o checked --target linux-x86_64 --profile linux-x86_64-scalar-v1 --no-metrics
./checked

100
100
true
true

// Bounded collections: Vec<T, N> and Str<N>. The capacity lives in the type,
// there is no heap, and an operation that will not fit returns a carrier
// instead of trapping.

fn main() -> i64 {
    let mut queue: Vec<i64, 3> = vec_empty();
    print(vec_len(&queue) == 0);

    vec_push(&mut queue, 10);
    vec_push(&mut queue, 20);
    vec_push(&mut queue, 30);
    print(vec_len(&queue) == 3);

    // The fourth push does not trap: it hands back Err and leaves the
    // vector byte-identical.
    let overflowed = vec_push(&mut queue, 40);
    match overflowed {
        Result::Ok(nothing) => { return -1; },
        Result::Err(rejected) => { print(rejected == 40); },
    }
    print(vec_len(&queue) == 3);

    let taken = vec_remove(&mut queue, 0);
    match taken {
        Result::Ok(value) => { print(value); },
        Result::Err(error) => { return -2; },
    }

    // Str<N> is a bounded byte buffer, also with its capacity in the type.
    let mut greeting: Str<16> = "hello";
    let target: Str<8> = ", world";
    let appended = str_append(&mut greeting, &target);
    match appended {
        // print takes i64 and bool only, and str_len returns u32.
        Result::Ok(nothing) => { print(str_len(&greeting) == 12); },
        Result::Err(full) => { return -3; },
    }

    let byte = str_byte(&greeting, 0);
    match byte {
        Result::Ok(value) => { print(value == 104); },
        Result::Err(out_of_range) => { return -4; },
    }

    // Reading past the stored length is refused, not a trap.
    let past_end = str_byte(&greeting, 200);
    match past_end {
        Result::Ok(value) => { return -5; },
        Result::Err(out_of_range) => { print(true); },
    }

    return 0;
}

ael check bounded.ael --tier core
ael compile bounded.ael -o bounded.aelir --target linux-x86_64 --no-metrics
ael build bounded.aelir -o bounded --target linux-x86_64 --profile linux-x86_64-scalar-v1 --no-metrics
./bounded

true
true
true
true
10
true
true
true

// The eight cast_* conversions are checked: a value the destination type
// cannot represent produces Err(CastError::OutOfRange), never a wrap
// and never a silent truncation.

fn narrow(value: i64) -> i64 {
    let converted: Result<i8, CastError> = cast_i8(value);
    match converted {
        Result::Ok(small) => { return 1; },
        Result::Err(error) => { return 0; },
    }
}

fn main() -> i64 {
    print(narrow(100) == 1);
    print(narrow(300) == 0);
    print(narrow(-129) == 0);
    print(narrow(-128) == 1);

    // The range test is taken at the source's signedness, so u64 at 2^63
    // is refused for i64 rather than read as negative.
    let big: u64 = 9223372036854775808;
    let widened: Result<i64, CastError> = cast_i64(big);
    match widened {
        Result::Ok(value) => { return -1; },
        Result::Err(error) => { print(true); },
    }

    return 0;
}

ael check casts.ael --tier core
ael compile casts.ael -o casts.aelir --target linux-x86_64 --no-metrics
ael build casts.aelir -o casts --target linux-x86_64 --profile linux-x86_64-scalar-v1 --no-metrics
./casts

true
true
true
true
true

// Checked arithmetic is the default. An overflow is a checked failure:
// the process reports it and stops, it does not wrap.

fn main() -> i64 {
    print(1);
    let limit: i64 = 9223372036854775807;
    let overflowed: i64 = limit + 1;
    print(overflowed);
    return 0;
}

$ ./overflow
1
AEL panic: arithmetic_overflow
$ echo $?
101

$ ./overflow 2>/dev/null
1

$ ./overflow 2>&1 1>/dev/null
AEL panic: arithmetic_overflow

// Every array index is compared against the length before the address is
// formed, at every integer kind, including a negative signed index.

fn main() -> i64 {
    let values: [i64; 3] = [1, 2, 3];
    let mut i: i64 = 0;
    while i < 4 {
        print(values[i]);
        i = i + 1;
    }
    return 0;
}

$ ./bounds
1
2
3
AEL panic: index_out_of_range
$ echo $?
101

$ ael init demo --profile ael-project-init-filesystem-candidate/1
initialized "/path/to/parent" / "demo"
roots main.ael pack.ael metadata.ael
plan sha256:…   # digest covers the plan and its parent path, so it differs per directory

$ ael check demo
Checked source/1 project …

$ ael compile demo -o demo.aelir --target linux-x86_64 --no-metrics
$ ael build demo.aelir -o demo-bin --target linux-x86_64 --profile linux-x86_64-scalar-v1 --no-metrics
$ ./demo-bin
$ echo $?
0

// main.ael
main main() {
    return;
}

// pack.ael
pack { schema = 1; dependencies = []; }

// metadata.ael
metadata {
    schema = 1;
    name = "demo";
    source_profile = "ael-source/1";
}

main main() -> i64 {
    let total: i64 = 6 * 7;
    print(total);
    return total;
}

fn down(n: i64) -> i64 {
    if n == 0 {
        return 0;
    }
    return down(n - 1) + 1;
}

fn main() -> i64 {
    print(down(100000000));
    return 0;
}

$ ./stack
Segmentation fault (core dumped)
$ echo $?
139