cbqn 0.2.3

Embed BQN in Rust via CBQN FFI
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
109
110
111
112
113
114
115
116
117
118
119

use super::*;

#[test]
fn fn1() -> Result<()> {
    let to_upper = BQNValue::fn1(|x| {
        let s = x.to_string().unwrap();
        BQNValue::from(&s.to_uppercase()[..])
    });
    assert_eq!(
        to_upper.call1(&"hello, world!".into())?.to_string()?,
        "HELLO, WORLD!"
    );

    Ok(())
}

#[test]
fn fn2() -> Result<()> {
    let split = BQNValue::fn2(|w, x| {
        x.to_string()
            .unwrap()
            .split(w.to_char().unwrap().unwrap())
            .collect::<Vec<_>>()
            .into()
    });
    assert_eq!(
        BQN!(split, "{' '𝕎𝕩}¨", ["Hello world!", "Rust ❤️ BQN"])?
            .to_bqnvalue_vec()?
            .iter()
            .map(|v| {
                v.to_bqnvalue_vec()
                    .unwrap()
                    .iter()
                    .map(|v| v.to_string().unwrap())
                    .collect()
            })
            .collect::<Vec<Vec<_>>>(),
        [vec!["Hello", "world!"], vec!["Rust", "❤️", "BQN"]]
    );
    Ok(())
}

#[test]
fn clone() -> Result<()> {
    let to_upper = BQNValue::fn1(|x| {
        let s = x.to_string().unwrap();
        BQNValue::from(&s.to_uppercase()[..])
    });
    let to_upper_2 = to_upper.clone();
    assert_eq!(
        to_upper.call1(&"hello, world!".into())?.to_string()?,
        "HELLO, WORLD!"
    );
    assert_eq!(
        to_upper_2.call1(&"hello, world!".into())?.to_string()?,
        "HELLO, WORLD!"
    );

    Ok(())
}

#[test]
#[ignore = "Ignored until I figure out how to make this work with Rust's changed extern C unwinding"]
#[should_panic]
fn boundfn_inside_boundfn() {
    let to_upper = BQNValue::fn1(|x| {
        let to_lower = BQNValue::fn1(|x| {
            let s = x.to_string().unwrap();
            BQNValue::from(&s.to_lowercase()[..])
        });
        let lower_x = to_lower.call1(x).unwrap();
        let s = lower_x.to_string().unwrap();
        BQNValue::from(&s.to_uppercase()[..])
    });
    let _ = to_upper.call1(&"hello".into());
}

#[test]
fn lifetime() -> Result<()> {
    fn boundfn() -> Result<BQNValue> {
        let f = BQNValue::fn1(|x| BQNValue::from(x.to_f64().unwrap() * 2.0));
        BQN!("⊢", f)
    }

    let f = boundfn()?;
    assert_eq!(f.call1(&1.0.into())?.to_f64()?, 2.0);

    Ok(())
}

#[test]
fn boundfn_count() {
    fn times2(x: &BQNValue) -> BQNValue {
        BQNValue::from(x.to_f64().unwrap() * 2.0)
    }

    let closure = |x: &BQNValue| BQNValue::from(x.to_f64().unwrap() * 2.0);

    // 1
    let _a = BQNValue::fn1(closure);
    let _b = BQNValue::fn1(closure);
    // 2
    let _c = BQNValue::fn1(|x| BQNValue::from(x.to_f64().unwrap() * 2.0));
    // 3
    let _d = BQNValue::fn1(|x| BQNValue::from(x.to_f64().unwrap() * 2.0));
    // 4
    let _e = BQNValue::fn1(times2);
    let _f = BQNValue::fn1(times2);

    // 5
    let _v = (0..5)
        .map(|_| BQNValue::fn1(|x| x.clone()))
        .collect::<Vec<BQNValue>>();

    FNS.with(|fns| {
        let fns = fns.borrow();
        assert_eq!(fns.boundfn_1.len(), 5);
    });
}