feat: init

src/builtins/mod.rs

@@ -0,0 +1,86 @@
+use derive_more::Constructor;
+
+use super::vm::Env;
+use super::vm::Symbol;
+use super::vm::Value;
+use crate::bytecode::Const;
+
+pub fn env() -> Env {
+    let mut env = Env::empty();
+    env.insert(Symbol::from("true"), Value::Const(Const::Bool(true)));
+    env.insert(Symbol::from("false"), Value::Const(Const::Bool(false)));
+
+    env.insert(Symbol::from("__add"), Value::PrimOp(PrimOp::new(2, |args| {
+        let [first, second]: [Value; 2] = args.try_into().unwrap();
+        first.add(second)
+    })));
+    env.insert(Symbol::from("__sub"), Value::PrimOp(PrimOp::new(2, |args| {
+        let [first, second]: [Value; 2] = args.try_into().unwrap();
+        first.add(second.neg())
+    })));
+    env.insert(Symbol::from("__mul"), Value::PrimOp(PrimOp::new(2, |args| {
+        let [first, second]: [Value; 2] = args.try_into().unwrap();
+        first.mul(second)
+    })));
+    env.insert(Symbol::from("__div"), Value::PrimOp(PrimOp::new(2, |args| {
+        let [first, second]: [Value; 2] = args.try_into().unwrap();
+        first.div(second)
+    })));
+    env.insert(Symbol::from("__lessThan"), Value::PrimOp(PrimOp::new(2, |args| {
+        let [first, second]: [Value; 2] = args.try_into().unwrap();
+        first.lt(second)
+    })));
+
+    env
+}
+
+#[derive(Debug, Clone, Constructor)]
+pub struct PrimOp {
+    arity: u8,
+    func: fn(Vec<Value>) -> Value,
+}
+
+impl PartialEq for PrimOp {
+    fn eq(&self, _: &Self) -> bool {
+        false
+    }
+}
+
+impl PrimOp {
+    pub fn call(self, args: Vec<Value>) -> Value {
+        if (args.len() as u8) < self.arity {
+            Value::PartialPrimOp(PartialPrimOp { arity: self.arity - args.len() as u8, args, func: self.func })
+        } else if args.len() as u8 == self.arity {
+            (self.func)(args)
+        } else {
+            unimplemented!()
+        }
+    }
+}
+
+#[derive(Debug, Clone)] 
+pub struct PartialPrimOp {
+    arity: u8,
+    args: Vec<Value>,
+    func: fn(Vec<Value>) -> Value
+}
+
+impl PartialEq for PartialPrimOp {
+    fn eq(&self, _: &Self) -> bool {
+        false
+    }
+}
+
+impl PartialPrimOp {
+    pub fn call(mut self, args: Vec<Value>) -> Value {
+        let len = args.len() as u8;
+        self.args.extend(args);
+        if len < self.arity {
+            Value::PartialPrimOp(PartialPrimOp { arity: self.arity - len, args: self.args, func: self.func })
+        } else if len == self.arity {
+            (self.func)(self.args)
+        } else {
+            unimplemented!()
+        }
+    }
+}