motoko 0.0.32

A library for parsing and running Motoko in Rust
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::ast::{BinOp, PrimType, RelOp, UnOp};
use crate::value::{Value, Value_};
use crate::vm_types::Interruption;
use num_bigint::{BigUint, ToBigInt};

use crate::{nyi, type_mismatch};

pub fn unop(un: UnOp, v: Value_) -> Result<Value, Interruption> {
    match (un, &*v) {
        (UnOp::Neg, Value::Nat(n)) => Ok(Value::Int(-n.to_bigint().unwrap())),
        (UnOp::Neg, _) => crate::nyi!(line!()),
        (UnOp::Pos, _) => crate::nyi!(line!()),
        (UnOp::Not, _) => crate::nyi!(line!()),
        /* _ => crate::nyi!(line!()), */
    }
}

pub fn binop(
    cont_prim_type: &Option<PrimType>,
    binop: BinOp,
    v1: Value_,
    v2: Value_,
) -> Result<Value, Interruption> {
    use BinOp::*;
    use Value::*;
    if let Unit = &*v1 {
        type_mismatch!(file!(), line!());
    };
    if let Unit = &*v2 {
        type_mismatch!(file!(), line!());
    };
    match binop {
        Add => match (&*v1, &*v2) {
            (Nat(n1), Nat(n2)) => Ok(Nat(n1 + n2)),
            (Int(i1), Int(i2)) => Ok(Int(i1 + i2)),
            (Float(f1), Float(f2)) => Ok(Float(*f1 + *f2)),
            // _ => nyi!(line!()),
            (v1, v2) => unimplemented!("{:?} + {:?}", v1, v2),
        },
        Div => match (&*v1, &*v2) {
            (Nat(n1), Nat(n2)) => Ok(Nat(n1 / n2)),
            (Int(i1), Int(i2)) => Ok(Int(i1 / i2)),
            (Float(f1), Float(f2)) => Ok(Float(*f1 / *f2)),
            // _ => nyi!(line!()),
            (v1, v2) => unimplemented!("{:?} + {:?}", v1, v2),
        },
        Sub => match (&*v1, &*v2) {
            (Nat(n1), Nat(n2)) => {
                if n2 > n1 {
                    Ok(Int(n1.to_bigint().unwrap() - n2.to_bigint().unwrap()))
                } else {
                    Ok(Nat(n1 - n2))
                }
            }
            (Int(i1), Int(i2)) => Ok(Int(i1 - i2)),
            (Int(i1), Nat(n2)) => Ok(Int(i1 - n2.to_bigint().unwrap())),
            (Nat(n1), Int(i2)) => Ok(Int(n1.to_bigint().unwrap() - i2)),
            (Float(f1), Float(f2)) => Ok(Float(*f1 - *f2)),
            // _ => nyi!(line!()),
            (v1, v2) => unimplemented!("{:?} - {:?}", v1, v2),
        },
        Mul => match (&*v1, &*v2) {
            (Nat(n1), Nat(n2)) => Ok(Nat(n1 * n2)),
            (Int(i1), Int(i2)) => Ok(Int(i1 * i2)),
            (Float(f1), Float(f2)) => Ok(Float(*f1 * *f2)),
            // _ => nyi!(line!()),
            (v1, v2) => unimplemented!("{:?} * {:?}", v1, v2),
        },
        WAdd => match (cont_prim_type, &*v1, &*v2) {
            (None, _, _) => Err(Interruption::AmbiguousOperation),
            (Some(t), Value::Nat(n1), Value::Nat(n2)) => match t {
                PrimType::Nat => Ok(Value::Nat(n1 + n2)),
                PrimType::Nat8 => Ok(Value::Nat(
                    (n1 + n2) % BigUint::parse_bytes(b"256", 10).unwrap(),
                )),
                _ => nyi!(line!()),
            },
            _ => nyi!(line!()),
        },

        Mod | Pow | And | Or | Xor | ShL | ShR | RotL | RotR | WSub | WMul | WPow | Cat | BitOr
        | BitAnd => nyi!(line!(), "binop({:?}. {:?}, {:?})", binop, v1, v2),
    }
}

pub fn relop(
    _cont_prim_xotype: &Option<PrimType>,
    relop: RelOp,
    v1: Value_,
    v2: Value_,
) -> Result<Value, Interruption> {
    use RelOp::*;
    use Value::*;
    Ok(Bool(match relop {
        Eq => match (&*v1, &*v2) {
            (Unit, Unit) => true,
            (Bool(b1), Bool(b2)) => b1 == b2,
            (Text(t1), Text(t2)) => t1 == t2,
            (Nat(n1), Nat(n2)) => n1 == n2,
            (Int(i1), Int(i2)) => i1 == i2,
            (v1, v2) => v1 == v2, //            _ => nyi!(line!(), "{:?} == {:?}", v1, v2)?,
        },
        Neq => match (&*v1, &*v2) {
            (Unit, Unit) => false,
            (Bool(b1), Bool(b2)) => b1 != b2,
            (Text(t1), Text(t2)) => t1 == t2,
            (Nat(n1), Nat(n2)) => n1 != n2,
            (Int(i1), Int(i2)) => i1 != i2,
            (v1, v2) => v1 != v2, //            _ => nyi!(line!(), "{:?} == {:?}", v1, v2)?,
        },
        Lt => match (&*v1, &*v2) {
            (Unit, Unit) => false,
            (Nat(n1), Nat(n2)) => n1 < n2,
            (Int(i1), Int(i2)) => i1 < i2,
            _ => nyi!(line!(), "{:?} < {:?}", v1, v2)?,
        },
        Le => match (&*v1, &*v2) {
            (Unit, Unit) => false,
            (Nat(n1), Nat(n2)) => n1 <= n2,
            (Int(i1), Int(i2)) => i1 <= i2,
            _ => nyi!(line!(), "{:?} <= {:?}", v1, v2)?,
        },
        Gt => match (&*v1, &*v2) {
            (Unit, Unit) => false,
            (Nat(n1), Nat(n2)) => n1 > n2,
            (Int(i1), Int(i2)) => i1 > i2,
            _ => nyi!(line!(), "{:?} > {:?}", v1, v2)?,
        },
        Ge => match (&*v1, &*v2) {
            (Unit, Unit) => false,
            (Nat(n1), Nat(n2)) => n1 >= n2,
            (Int(i1), Int(i2)) => i1 >= i2,
            _ => nyi!(line!(), "{:?} >= {:?}", v1, v2)?,
        },
        //        _ => nyi!(line!(), "relop({:?}, {:?}, {:?})", relop, v1, v2)?,
    }))
}