blisp 0.4.7

A lisp like statically typed programing language for no_std.
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

use blisp::embedded;
use num_bigint::{BigInt, ToBigInt};

#[embedded]
fn test_fun(
    _z: BigInt,
    _a: Vec<BigInt>,
    _b: (BigInt, BigInt),
    _c: Option<BigInt>,
    _d: Result<BigInt, String>,
) -> Option<BigInt> {
    let temp = 5.to_bigint();
    temp
}

#[embedded]
fn add_four_ints(a: BigInt, b: (BigInt, BigInt), c: Option<BigInt>) -> Result<BigInt, String> {
    let mut result = a + b.0 + b.1;
    if let Some(n) = c {
        result += n;
    }

    Ok(result)
}

#[embedded]
fn no_return() {}

#[test]
fn test_embedded() {
    // test_fun
    let code = "(export call_test_fun ()
        (IO (-> () (Option Int)))
        (test_fun 1 '(2 3) [4 5] (Some 6) (Ok 7))
    )";
    let exprs = blisp::init(code, vec![Box::new(TestFun)]).unwrap();
    let ctx = blisp::typing(exprs).unwrap();
    let result = blisp::eval("(call_test_fun)", &ctx).unwrap();

    let front = result.front().unwrap().as_ref().unwrap();
    assert_eq!(front, "(Some 5)");

    // add_for_ints
    let code = "(export call_add_four_ints (n)
        (IO (-> ((Option Int)) (Result Int String)))
        (add_four_ints 1 [2 3] n)
    )";
    let exprs = blisp::init(code, vec![Box::new(AddFourInts)]).unwrap();
    let ctx = blisp::typing(exprs).unwrap();
    let result = blisp::eval("(call_add_four_ints (Some 4))", &ctx).unwrap();

    let front = result.front().unwrap().as_ref().unwrap();
    assert_eq!(front, "(Ok 10)");

    // no_return
    let code = "(export call_no_return ()
        (IO (-> () []))
        (no_return)
    )";
    let exprs = blisp::init(code, vec![Box::new(NoReturn)]).unwrap();
    let ctx = blisp::typing(exprs).unwrap();
    let result = blisp::eval("(call_no_return)", &ctx).unwrap();
    result.front().unwrap().as_ref().unwrap();
}