rex 3.9.12

Rex: A strongly-typed, pure, implicitly parallel functional programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use rex::{BuiltinTypeId, Engine, GasMeter, Library, Parser, ParserErr, Token, Type, Value};

fn format_parse_errors(errs: &[ParserErr]) -> String {
    let mut out = String::from("parse error:");
    for err in errs {
        out.push_str(&format!("\n  {err}"));
    }
    out
}

async fn assert_program_ok(name: &str, source: &str, expected_value: i32, expected_type: Type) {
    let tokens = Token::tokenize(source).unwrap_or_else(|err| panic!("{name}: lex error: {err}"));
    let mut parser = Parser::new(tokens);
    let program = parser
        .parse_program(&mut GasMeter::default())
        .unwrap_or_else(|errs| panic!("{name}:\n{}", format_parse_errors(&errs)));

    let mut engine = Engine::with_prelude(()).unwrap();
    let mut library = Library::global();
    library.add_decls(program.decls.clone());
    engine
        .inject_library(library)
        .unwrap_or_else(|err| panic!("{name}: engine decl error: {err}"));
    let mut gas = GasMeter::default();
    let (value, ty) = rex::Evaluator::new_with_compiler(
        rex::RuntimeEnv::new(engine.clone()),
        rex::Compiler::new(engine.clone()),
    )
    .eval(program.expr.as_ref(), &mut gas)
    .await
    .unwrap_or_else(|err| panic!("{name}: eval error: {err}"));
    assert_eq!(ty, expected_type, "{name}: unexpected eval type");

    let value = engine
        .heap
        .get(&value)
        .map(|value| value.as_ref().clone())
        .unwrap_or_else(|err| panic!("{name}: heap read error: {err}"));
    match value {
        Value::I32(actual) => assert_eq!(actual, expected_value, "{name}: unexpected eval value"),
        _ => panic!("{name}: expected i32 result"),
    }
}

#[tokio::test]
async fn example_adt_record_constructor() {
    assert_program_ok(
        "adt_record_constructor",
        r#"
            type Foo = Bar { x: i32, y: i32 }

            let v: Foo = Bar { x = 1, y = 2 } in
              v.x + v.y
        "#,
        3,
        Type::builtin(BuiltinTypeId::I32),
    )
    .await;
}

#[tokio::test]
async fn example_nested_lets() {
    assert_program_ok(
        "nested_lets",
        r#"
            let
              a = 1,
              b = 2,
              c = a + b
            in c
        "#,
        3,
        Type::builtin(BuiltinTypeId::I32),
    )
    .await;
}

#[tokio::test]
async fn example_lambda_application() {
    assert_program_ok(
        "lambda_application",
        r#"
            let inc = \x -> x + 1 in
              inc 41
        "#,
        42,
        Type::builtin(BuiltinTypeId::I32),
    )
    .await;
}

#[tokio::test]
async fn example_match() {
    assert_program_ok(
        "match",
        r#"
            type Sum = A { x: i32 } | B { x: i32 }

            let v: Sum = A { x = 7 } in
              match v
                when A {x} -> x
                when B {x} -> x + 100
        "#,
        7,
        Type::builtin(BuiltinTypeId::I32),
    )
    .await;
}