cairo-native 0.9.0-rc.3

A compiler to convert Cairo's IR Sierra code to MLIR and execute it.
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

#[test]
fn closure() {
    let x = 8;
    let c = |a| {
        if a == 2 {
            return x * (a + 3);
        }
        7_felt252
    };
    assert_eq!(c(2), 40);
}

#[derive(Destruct)]
struct DestructOnly {}

#[test]
fn closure_destruct() {
    let a = DestructOnly {};
    || {
        let _b = a;
    };
}

#[derive(PanicDestruct)]
struct PanicDestructOnly {}

#[test]
#[should_panic(expected: "outer")]
fn closure_panic_destruct() {
    let a = PanicDestructOnly {};
    || -> () {
        let _b = a;
        panic!("inner")
    };
    panic!("outer")
}

#[test]
fn panicable_closure() {
    let c = |a: u32| {
        a + 3
    };
    assert_eq!(c(2), 5);
}

struct Callable<F, +core::ops::Fn<F, ()>> {
    f: F,
}

#[test]
fn closure_snapshot_call() {
    let callable = Callable { f: || 10_u8 };
    assert_eq!(core::ops::FnOnce::call(callable.f, ()), 10);
    assert_eq!(core::ops::Fn::call(@callable.f, ()), 10);
    // With snapshot
    assert_eq!(core::ops::FnOnce::call(@callable.f, ()), 10);
    assert_eq!(core::ops::Fn::call(@@callable.f, ()), 10);
}

fn option_map<T, F, +core::ops::FnOnce<F, (T,)>, +Drop<F>>(
    opt: Option<T>, f: F,
) -> Option<core::ops::FnOnce::<F, (T,)>::Output> {
    match opt {
        Some(x) => Some(f(x)),
        None => None,
    }
}

#[test]
fn option_map_test() {
    assert_eq!(option_map(Some(2), |x| x + 3), Some(5));
    assert_eq!(option_map(None, |x| x + 3), None);
    assert_eq!(option_map(Some(2), |x| Some(x)), Some(Some(2)));
}

fn fix_sized_array_map<
    T, F, impl Fn: core::ops::Fn<F, (T,)>, +Drop<T>, +Drop<F>, +Drop<Fn::Output>,
>(
    arr: [T; 2], f: F,
) -> [core::ops::Fn::<F, (T,)>::Output; 2] {
    let [a, b] = arr;
    [f(a), f(b)]
}

#[test]
fn fix_sized_array_map_test() {
    assert_eq!(fix_sized_array_map([2, 3], |x| x + 3), [5, 6]);
}

#[generate_trait]
impl ArrayExt of ArrayExtTrait {
    fn map<T, +Drop<T>, F, +Drop<F>, impl func: core::ops::Fn<F, (T,)>, +Drop<func::Output>>(
        self: Array<T>, f: F,
    ) -> Array<func::Output> {
        let mut output: Array<func::Output> = array![];
        for elem in self {
            output.append(f(elem));
        }
        output
    }
}

#[test]
fn array_map_test() {
    let arr = array![1, 2, 3];
    let result = arr.map(|x| x + 1);
    assert_eq!(result, array![2, 3, 4]);
}