remove workflow

.github/workflows/notify-bot-updated.yml

@@ -1,19 +0,0 @@
-name: Trigger Bot Build
-
-on:
-  push:
-    branches:
-      - dev
-
-jobs:
-  trigger-bot-build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Send repository dispatch
-        env:
-          GITHUB_TOKEN: ${{ secrets.LAMM_TOKEN }}
-        run: |
-          curl -X POST -H "Accept: application/vnd.github.everest-preview+json" \
-          -H "Authorization: token $GITHUB_TOKEN" \
-          https://api.github.com/repos/minneelyyyy/bot/dispatches \
-          -d '{"event_type": "lamm-updated"}'

Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 4
+version = 3
 
 [[package]]
 name = "aho-corasick"
@@ -13,7 +13,7 @@ dependencies = [
 
 [[package]]
 name = "lamm"
-version = "0.1.0"
+version = "0.4.0"
 dependencies = [
  "regex",
 ]
@@ -26,9 +26,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "regex"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
  "aho-corasick",
  "memchr",

README.md

@@ -77,43 +77,53 @@ export (e phi)
 All functions in Lamm are **scoped** similarly to variables. Functions are declared using the `:` operator, which can be extended with more `:` and `.` characters to let Lamm know how many arguments the function takes.
 
 ```
-: inc x + x 1
+: inc x
-	inc 24  # => 25
+	+ x 1
+(inc 24)  # => 25
 
-:. pythag a b sqrt + ** a 2.0 ** b 2.0
+: sqrt x
-	pythag 3 4  # => 5
+	** x 0.5
+
+:. pythag a b
+	(sqrt + ** a 2.0 ** b 2.0)
+(pythag 3 4)  # => 5
 
 :::::. ten'args a b c d e f g h i j
 	[a b c d e f g h i j]
 ```
 
 The parameter types and return type of functions can be declared using a special syntax unique to function and lambda definitions.
+Calling a function requires parenthises around the call.
 
 ```
 # Takes an x of `Any` type
-: inc x + x 1
+: inc x
-	inc 12  # => 13
+	+ x 1
+(inc 12)  # => 13
 
 # Takes an x of `Int` and returns an `Int`
-: inc ?. x Int -> Int + x 1
+: inc ?. x Int -> Int
-	inc 9  # => 10
+	+ x 1
+(inc 9)  # => 10
 ```
 
 The `?.` operator is unique to function declarations and is used to specify the type of an argument. There are also first class functions, here is the syntax for it.
 
 ```
 # Applies a function to any value
-:. apply : f x f x
+:. apply : f x
-	apply \sqrt 9  # => 3
+	(f x)
+(apply sqrt 9)  # => 3
 
 # Applies a function f which maps an Int to an Int to x
-:. apply'int ?: f Int -> Int ?. x Int -> Int f x
+:. apply'int ?: f Int -> Int ?. x Int -> Int
-	apply'int \sqrt 36  # => 6
+	(f x)
+(apply'int sqrt 36)  # => 6
 ```
 
-The `:` operator inside of a function prototype tells Lamm that this argument must be a function where every argument and it's return type are all `Any`. This means that `: f` is essentially syntactic sugar for `?: f Any -> Any`. Also, in order to pass a function to a function, you must use the `\` operator, which tells Lamm not to call the function.
+The `:` operator inside of a function prototype tells Lamm that this argument must be a function where every argument and it's return type are all `Any`. This means that `: f` is essentially syntactic sugar for `?: f Any -> Any`. You can pass a function with just it's identifier.
 
-And off course, `:` and `?:` in function prototypes can also be extended depending on the number of arguments the function must take.
+And of course, `:` and `?:` in function prototypes can also be extended depending on the number of arguments the function must take.
 
 ## Branching
 
@@ -171,28 +181,28 @@ Using these, you can build a lot of fundamental functional paradigm functions.
 
 ```
 :. map : f ?. x [] -> []
-	?? bool x
+  ?? bool x
-		+ f head x map \f tail x
+    [+ (f head x) (map f tail x)
-		empty
+    empty
-map ;x ** x 2 [1 2 3 4 5 6 7 8 9 10]  # => [1 4 9 16 25 36 49 64 81 100]
+(map ;x ** x 2 [1 2 3 4 5 6 7 8 9 10])  # => [1 4 9 16 25 36 49 64 81 100]
 
 :: iterate : f i count -> []
-	?? > count 0 
+  ?? > count 0
-		+ i iterate \f f i - count 1
+    [+ i (iterate f (f i) - count 1)
-		empty
+    empty
-iterate (+ 1) 0 10  # => [0 1 2 3 4 5 6 7 8 9]
+(iterate (+ 1) 0 10)  # => [0 1 2 3 4 5 6 7 8 9]
 
 :. take ?. n Int ?. x [] -> []
 	?? > n 0
-		+ head x take - n 1 tail x
+		[+ head x (take - n 1 tail x)
 		empty
-take 3 [1 2 3 4 5]  # => [1 2 3]
+(take 3 [1 2 3 4 5])  # => [1 2 3]
 
 :. take'while ?: pred Any -> Bool ?. x [] -> []
-	?? && bool x pred head x
+	?? && bool x (pred head x)
-		+ head x take'while \pred tail x
+		[+ head x (take'while pred tail x)
 		empty
-take'while (> 10) [1 3 5 7 9 11 13 15 16]  # => [1 3 5 7 9]
+(take'while (> 10) [1 3 5 7 9 11 13 15 16])  # => [1 3 5 7 9]
 ```
 
 ## Lambdas

src/executor.rs

@@ -89,227 +89,217 @@ impl Executor {
         locals
     }
 
+    fn op_error(op: &Op, args: &[Value]) -> Error {
+        Error::new(format!("no overload of {op} matches the arguments {}",
+                           args.iter().map(|x| format!("{x}")).collect::<Vec<_>>().join(", ")))
+    }
+
     pub(crate) fn exec(&mut self, tree: ParseTree) -> Result<Value, Error> {
         match tree {
             ParseTree::Operator(op, args) => {
                 let args: Vec<Value> = args.into_iter()
                     .map(|x| self.exec(x)).collect::<Result<_, _>>()?;
 
-                match op {
+                match (&op, &args[..]) {
-                    Op::Add => match &args[..] {
+                    (Op::Add, [x, y]) => match (x, y) {
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Int(x + y)),
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Int(x + y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Float(x + *y as f64)),
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Float(x + *y as f64)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Float(*x as f64 + y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Float(*x as f64 + y)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Float(x + y)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Float(x + y)),
-                        [Value::String(x), Value::String(y)] => Ok(Value::String(format!("{x}{y}"))),
+                        (Value::String(x), Value::String(y)) => Ok(Value::String(format!("{x}{y}"))),
-                        [Value::Array(xtype, x), Value::Array(ytype, y)] => {
+                        _ => Err(Self::op_error(&op, &args)),
+                    },
+                    (Op::Neg, [x]) => match x {
+                        Value::Int(x) => Ok(Value::Int(-x)),
+                        Value::Float(x) => Ok(Value::Float(-x)),
+                        _ => Err(Self::op_error(&op, &args)),
+                    },
+                    (Op::Concat, [x, y]) => match (x, y) {
+                        (Value::Array(xtype, x), Value::Nil) => Ok(Value::Array(xtype.clone(), x.clone())),
+                        (Value::Nil, Value::Array(xtype, x)) => Ok(Value::Array(xtype.clone(), x.clone())),
+                        (Value::Array(xtype, x), Value::Array(ytype, y)) =>
                             if xtype != ytype {
-                                return Err(Error::new(format!("expected type {} but found {}", xtype, ytype)));
+                                Err(Error::new(format!("expected type {} but found {}", xtype, ytype)))
-                            }
+                            } else {
-
+                                Ok(Value::Array(xtype.clone(), [x.clone(), y.clone()].concat()))
-                            Ok(Value::Array(xtype.clone(), [x.clone(), y.clone()].concat()))
+                            },
-                        },
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Nil, x] => Ok(x.clone()),
+                    },
-                        [x, Value::Nil] => Ok(x.clone()),
+                    (Op::Prepend, [x, y]) => match (x, y) {
-                        [Value::Array(t, x), y] => {
+                        (Value::Nil, Value::Array(xtype, x)) => Ok(Value::Array(xtype.clone(), x.clone())),
-                            let ytype = y.get_type();
+                        (x, Value::Array(t, y)) => {
-
-                            if *t != ytype {
-                                return Err(Error::new(format!("expected type {} but found {}", t, ytype)));
-                            }
-
-                            // NOTE: use y's type instead of the arrays type.
-                            // an `empty` array has Any type, but any value will have a fixed type.
-                            // this converts the empty array into a typed array.
-                            Ok(Value::Array(ytype, [x.clone(), vec![y.clone()]].concat()))
-                        },
-                        [x, Value::Array(t, y)] => {
                             let xtype = x.get_type();
-
                             if *t != xtype {
-                                return Err(Error::new(format!("expected type {} but found {}", t, xtype)));
+                                Err(Error::new(format!("expected type {} but found {}", t, xtype)))
+                            } else {
+                                Ok(Value::Array(xtype, [vec![x.clone()], y.clone()].concat()))
                             }
-
-                            // NOTE: read above
-                            Ok(Value::Array(xtype, [vec![x.clone()], y.clone()].concat()))
                         },
-                        _ => Err(Error::new("todo: add".into())),
+                        _ => Err(Self::op_error(&op, &args)),
-                    }
+                    },
-                    Op::Sub => match &args[..] {
+                    (Op::Append, [x, y]) => match (x, y) {
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Int(x - y)),
+                        (Value::Array(xtype, x), Value::Nil) => Ok(Value::Array(xtype.clone(), x.clone())),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Float(*x as f64 - y)),
+                        (Value::Array(t, y), x) => {
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Float(x - *y as f64)),
+                            let xtype = x.get_type();
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Float(x - y)),
+                            if *t != xtype {
-                        [Value::Nil, x] => Ok(x.clone()),
+                                Err(Error::new(format!("expected type {} but found {}", t, xtype)))
-                        [x, Value::Nil] => Ok(x.clone()),
+                            } else {
-                        _ => Err(Error::new("todo: actual error output".into())),
+                                Ok(Value::Array(xtype, [y.clone(), vec![x.clone()]].concat()))
-                    }
+                            }
-                    Op::Mul => match &args[..] {
+                        },
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Int(x * y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Float(*x as f64 * y)),
+                    },
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Float(x * *y as f64)),
+                    (Op::Insert, [Value::Int(idx), x, Value::Array(t, y)]) => {
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Float(x * y)),
+                        let mut y = y.clone();
-                        [Value::Nil, x] => Ok(x.clone()),
+                        let xtype = x.get_type();
-                        [x, Value::Nil] => Ok(x.clone()),
+                        if *t != xtype {
-                        _ => Err(Error::new("todo: actual error output".into())),
+                            Err(Error::new(format!("expected type {} but found {}", t, xtype)))
-                    }
+                        } else if *idx as usize > y.len() {
-                    Op::Div => match &args[..] {
+                            Err(Error::new("attempt to insert out of array len".into()))
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Float(*x as f64 / *y as f64)),
+                        } else {
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Float(x / *y as f64)),
+                            y.insert(*idx as usize, x.clone());
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Float(*x as f64 / y)),
+                            Ok(Value::Array(t.clone(), y))
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Float(x / y)),
+                        }
-                        [Value::Nil, x] => Ok(x.clone()),
+                    },
-                        [x, Value::Nil] => Ok(x.clone()),
+                    (Op::Sub, [x, y]) => match (x, y) {
-                        _ => Err(Error::new("todo: actual error output".into())),
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Int(x - y)),
-                    }
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Float(*x as f64 - y)),
-                    Op::FloorDiv => match &args[..] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Float(x - *y as f64)),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Int(x / y)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Float(x - y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Int(*x as i64 / y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Int(x / *y as i64)),
+                    },
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Int(*x as i64 / *y as i64)),
+                    (Op::Mul, [x, y]) => match (x, y) {
-                        [Value::Nil, x] => Ok(x.clone()),
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Int(x * y)),
-                        [x, Value::Nil] => Ok(x.clone()),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Float(*x as f64 * y)),
-                        _ => Err(Error::new("todo: actual error output".into())),
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Float(x * *y as f64)),
-                    }
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Float(x * y)),
-                    Op::Exp => match &args[..] {
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Float((*x as f64).powf(*y as f64))),
+                    },
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Float(x.powf(*y as f64))),
+                    (Op::Div, [x, y]) => match (x, y) {
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Float((*x as f64).powf(*y))),
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Float(*x as f64 / *y as f64)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Float(x.powf(*y))),
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Float(x / *y as f64)),
-                        [Value::Nil, x] => Ok(x.clone()),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Float(*x as f64 / y)),
-                        [x, Value::Nil] => Ok(x.clone()),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Float(x / y)),
-                        _ => Err(Error::new("todo: fsadfdsf".into())),
+                        _ => Err(Self::op_error(&op, &args)),
-                    }
+                    },
-                    Op::Mod => match &args[..] {
+                    (Op::FloorDiv, [x, y]) => match (x, y) {
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Int(x % y)),
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Int(x / y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Float(x % *y as f64)),
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Int(*x as i64 / y)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Float(*x as f64 % y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Int(x / *y as i64)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Float(x % y)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Int(*x as i64 / *y as i64)),
-                        [Value::Nil, x] => Ok(x.clone()),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [x, Value::Nil] => Ok(x.clone()),
+                    },
-                        _ => Err(Error::new("todo: actual error output".into())),
+                    (Op::Exp, [x, y]) => match (x, y) {
-                    }
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Float((*x as f64).powf(*y as f64))),
-                    Op::GreaterThan => match &args[..] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Float(x.powf(*y as f64))),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Bool(x > y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Float((*x as f64).powf(*y))),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Bool(*x > *y as f64)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Float(x.powf(*y))),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Bool(*x as f64 > *y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Bool(x > y)),
+                    },
-                        _ => Err(Error::new("todo: actual error output".into())),
+                    (Op::Mod, [x, y]) => match (x, y) {
-                    }
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Int(x % y)),
-                    Op::GreaterThanOrEqualTo => match &args[..] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Float(x % *y as f64)),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Bool(x >= y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Float(*x as f64 % y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Bool(*x >= *y as f64)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Float(x % y)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Bool(*x as f64 >= *y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Bool(x >= y)),
+                    },
-                        _ => Err(Error::new("todo: actual error output".into())),
+                    (Op::GreaterThan, [x, y]) => match (x, y) {
-                    }
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Bool(x > y)),
-                    Op::LessThan => match &args[..] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Bool(*x > *y as f64)),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Bool(x < y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Bool(*x as f64 > *y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Bool(*x < *y as f64)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Bool(x > y)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Bool((*x as f64) < *y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Bool(x < y)),
+                    },
-                        _ => Err(Error::new("todo: actual error output".into())),
+                    (Op::GreaterThanOrEqualTo, [x, y]) => match (x, y) {
-                    }
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Bool(x >= y)),
-                    Op::LessThanOrEqualTo => match &args[..] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Bool(*x >= *y as f64)),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Bool(x <= y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Bool(*x as f64 >= *y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Bool(*x <= *y as f64)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Bool(x >= y)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Bool(*x as f64 <= *y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Bool(x <= y)),
+                    },
-                        _ => Err(Error::new("todo: actual error output".into())),
+                    (Op::LessThan, [x, y]) => match (x, y) {
-                    }
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Bool(x < y)),
-                    Op::EqualTo => match &args[..] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Bool(*x < *y as f64)),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Bool(x == y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Bool((*x as f64) < *y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Bool(*x == *y as f64)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Bool(x < y)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Bool(*x as f64 == *y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Bool(x == y)),
+                    },
-                        _ => Err(Error::new("todo: actual error output".into())),
+                    (Op::LessThanOrEqualTo, [x, y]) => match (x, y) {
-                    }
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Bool(x <= y)),
-                    Op::NotEqualTo => match &args[..] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Bool(*x <= *y as f64)),
-                        [Value::Int(x), Value::Int(y)] => Ok(Value::Bool(x != y)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Bool(*x as f64 <= *y)),
-                        [Value::Float(x), Value::Int(y)] => Ok(Value::Bool(*x != *y as f64)),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Bool(x <= y)),
-                        [Value::Int(x), Value::Float(y)] => Ok(Value::Bool(*x as f64 != *y)),
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Float(x), Value::Float(y)] => Ok(Value::Bool(x != y)),
+                    },
-                        _ => Err(Error::new("todo: actual error output".into())),
+                    (Op::EqualTo, [x, y]) => match (x, y) {
-                    }
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Bool(x == y)),
-                    Op::Not => match &args[0] {
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Bool(*x == *y as f64)),
-                        Value::Bool(b) => Ok(Value::Bool(!b)),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Bool(*x as f64 == *y)),
-                        _ => Err(Error::new("todo: actual error output".into())),
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Bool(x == y)),
-                    }
+                        _ => Err(Self::op_error(&op, &args)),
-                    Op::Or => match &args[..] {
+                    },
-                        [Value::Bool(x), Value::Bool(y)] => Ok(Value::Bool(*x || *y)),
+                    (Op::NotEqualTo, [x, y]) => match (x, y) {
-                        [Value::Nil, x] => Ok(x.clone()),
+                        (Value::Int(x), Value::Int(y)) => Ok(Value::Bool(x != y)),
-                        [x, Value::Nil] => Ok(x.clone()),
+                        (Value::Float(x), Value::Int(y)) => Ok(Value::Bool(*x != *y as f64)),
-                        _ => Err(Error::new("todo: actual error output".into())),
+                        (Value::Int(x), Value::Float(y)) => Ok(Value::Bool(*x as f64 != *y)),
-                    }
+                        (Value::Float(x), Value::Float(y)) => Ok(Value::Bool(x != y)),
-                    Op::And => match &args[..] {
+                        _ => Err(Self::op_error(&op, &args)),
-                        [Value::Bool(x), Value::Bool(y)] => Ok(Value::Bool(*x && *y)),
+                    },
-                        [Value::Nil, x] => Ok(x.clone()),
+                    (Op::Not, [Value::Bool(b)]) => Ok(Value::Bool(!b)),
-                        [x, Value::Nil] => Ok(x.clone()),
+                    (Op::Or, [x, y]) => match (x, y) {
-                        _ => Err(Error::new("todo: actual error output".into())),
+                        (Value::Bool(x), Value::Bool(y)) => Ok(Value::Bool(*x || *y)),
-                    }
+                        _ => Err(Self::op_error(&op, &args)),
-                    Op::Compose => match &args[..] {
+                    },
-                        [_, v] => Ok(v.clone()),
+                    (Op::And, [x, y]) => match (x, y) {
-                        _ => Err(Error::new("todo: actual error output".into())),
+                        (Value::Bool(x), Value::Bool(y)) => Ok(Value::Bool(*x && *y)),
-                    }
+                        _ => Err(Self::op_error(&op, &args)),
-                    Op::Head => match &args[0] {
+                    },
-                        Value::Array(_, x) => Ok(x.first().ok_or(Error::new(format!("passed an empty array to head")))?.clone()),
+                    (Op::Compose, [_, v]) => Ok(v.clone()),
-                        _ => Err(Error::new("head".into())),
+                    (Op::Head, [Value::Array(_, x)]) => Ok(x.first().ok_or(Error::new("passed an empty array to head".into()))?.clone()),
-                    }
+                    (Op::Tail, [Value::Array(t, x)]) => Ok(Value::Array(t.clone(), if x.len() > 0 { x[1..].to_vec() } else { vec![] })),
-                    Op::Tail => match &args[0] {
+                    (Op::Init, [Value::Array(t, x)]) => Ok(Value::Array(t.clone(), if x.len() > 0 { x[..x.len() - 1].to_vec() } else { vec![] })),
-                        Value::Array(t, x) => Ok(Value::Array(t.clone(), if x.len() > 0 { x[1..].to_vec() } else { vec![] })),
+                    (Op::Fini, [Value::Array(_, x)]) => Ok(x.last().ok_or(Error::new("passed an empty array to fini".into()))?.clone()),
-                        _ => Err(Error::new("tail".into())),
+                    (Op::Id, [x]) => Ok(x.clone()),
-                    }
+                    (Op::IntCast, [x]) => match x {
-                    Op::Init => match &args[0] {
-                        Value::Array(t, x) => Ok(Value::Array(t.clone(), if x.len() > 0 { x[..x.len() - 1].to_vec() } else { vec![] })),
-                        _ => Err(Error::new("init".into())),
-                    }
-                    Op::Fini => match &args[0] {
-                        Value::Array(_, x) => Ok(x.last().ok_or(Error::new(format!("passed an empty array to fini")))?.clone()),
-                        _ => Err(Error::new("fini".into())),
-                    }
-                    Op::Id => match &args[0] {
-                        x => Ok(x.clone()),
-                    }
-                    Op::IntCast => match &args[0] {
                         Value::Int(x) => Ok(Value::Int(*x)),
                         Value::Float(x) => Ok(Value::Int(*x as i64)),
                         Value::Bool(x) => Ok(Value::Int(if *x { 1 } else { 0 })),
                         Value::String(x) => {
                             let r: i64 = x.parse().map_err(|_| Error::new(format!("failed to parse {} into {}", x, Type::Int)))?;
                             Ok(Value::Int(r))
-                        }
+                        },
-                            x => Err(Error::new(format!("no possible conversion from {} into {}", x, Type::Int))),
+                        _ => Err(Error::new(format!("no possible conversion from {} into {}", x, Type::Int))),
-                    }
+                    },
-                    Op::FloatCast => match &args[0] {
+                    (Op::FloatCast, [x]) => match x {
                         Value::Int(x) => Ok(Value::Float(*x as f64)),
                         Value::Float(x) => Ok(Value::Float(*x)),
                         Value::Bool(x) => Ok(Value::Float(if *x { 1.0 } else { 0.0 })),
                         Value::String(x) => {
                             let r: f64 = x.parse().map_err(|_| Error::new(format!("failed to parse {} into {}", x, Type::Float)))?;
                             Ok(Value::Float(r))
-                        }
+                        },
-                        x => Err(Error::new(format!("no possible conversion from {} into {}", x, Type::Float))),
+                        _ => Err(Error::new(format!("no possible conversion from {} into {}", x, Type::Float))),
-                    }
+                    },
-                    Op::BoolCast => match &args[0] {
+                    (Op::BoolCast, [x]) => match x {
                         Value::Int(x) => Ok(Value::Bool(*x != 0)),
                         Value::Float(x) => Ok(Value::Bool(*x != 0.0)),
                         Value::Bool(x) => Ok(Value::Bool(*x)),
                         Value::String(x) => Ok(Value::Bool(!x.is_empty())),
                         Value::Array(_, vec) => Ok(Value::Bool(!vec.is_empty())),
-                        x => Err(Error::new(format!("no possible conversion from {} into {}", x, Type::Bool))),
+                        _ => Err(Error::new(format!("no possible conversion from {} into {}", x, Type::Bool))),
-                    }
+                    },
-                    Op::StringCast => Ok(Value::String(format!("{}", &args[0]))),
+                    (Op::StringCast, [x]) => Ok(Value::String(format!("{}", x))),
-                    Op::Print => match &args[0] {
+                    (Op::Print, [x]) => match x {
                         Value::String(s) => {
                             println!("{s}");
                             Ok(Value::Nil)
                         }
-                        x => {
+                        _ => {
                             println!("{x}");
                             Ok(Value::Nil)
                         }
-                    }
+                    },
-                    _ => unreachable!(),
+                    _ => Err(Self::op_error(&op, &args)),
                 }
             }
             ParseTree::Equ(ident, body, scope) => {
@@ -319,7 +309,9 @@ impl Executor {
                     let value = self.exec(*body)?;
                     let g = self.globals.clone();
 
-                    let r = self.add_local_mut(ident.clone(), Arc::new(Mutex::new(Object::value(value, g, self.locals.to_owned()))))
+                    let r = self.add_local_mut(
+                        ident.clone(),
+                        Arc::new(Mutex::new(Object::value(value, g, self.locals.to_owned()))))
                         .exec(*scope);
 
                     self.locals.remove(&ident);
@@ -418,13 +410,6 @@ impl Executor {
 
                 Ok(Value::Nil)
             }
-            ParseTree::NonCall(name) => {
-                let obj = self.get_object_mut(&name)?;
-
-                let v = obj.lock().unwrap().eval()?;
-
-                Ok(v)
-            }
             ParseTree::_Local(_idx) => todo!(),
             ParseTree::GeneratedFunction(function) => Ok(Value::Function(function.globals(self.globals.clone()).locals(self.locals.clone()))),
         }

src/function.rs

@@ -119,12 +119,6 @@ impl Function {
                 ParseTree::Value(_) => body,
                 ParseTree::Nop => body,
                 ParseTree::Export(_) => body,
-                ParseTree::NonCall(ref var) => if let Some(idx) =
-                    args.into_iter().position(|r| *r == *var) {
-                        Box::new(ParseTree::_Local(idx))
-                    } else {
-                        body
-                    }
                 ParseTree::GeneratedFunction(_) => todo!(),
             }
         }

src/parser.rs

@@ -4,6 +4,7 @@ use super::error::Error;
 
 use std::collections::HashMap;
 use std::iter::Peekable;
+use std::cmp::Ordering;
 
 #[derive(Clone, Debug)]
 pub(crate) enum ParseTree {
@@ -28,7 +29,6 @@ pub(crate) enum ParseTree {
     GeneratedFunction(Function),
 
     Nop,
-    NonCall(String),
     Export(Vec<String>),
 }
 
@@ -109,6 +109,7 @@ impl Parser {
         let operators: HashMap<Op, FunctionType> = HashMap::from([
             (Op::Add, FunctionType(Box::new(Type::Any), vec![Type::Any, Type::Any])),
             (Op::Sub, FunctionType(Box::new(Type::Any), vec![Type::Any, Type::Any])),
+            (Op::Neg, FunctionType(Box::new(Type::Any), vec![Type::Any])),
             (Op::Mul, FunctionType(Box::new(Type::Any), vec![Type::Any, Type::Any])),
             (Op::Div, FunctionType(Box::new(Type::Float), vec![Type::Any, Type::Any])),
             (Op::FloorDiv, FunctionType(Box::new(Type::Int), vec![Type::Any, Type::Any])),
@@ -125,6 +126,10 @@ impl Parser {
             (Op::And, FunctionType(Box::new(Type::Bool), vec![Type::Bool, Type::Bool])),
             (Op::Or, FunctionType(Box::new(Type::Bool), vec![Type::Bool, Type::Bool])),
             (Op::Head, FunctionType(Box::new(Type::Any), vec![Type::Array(Box::new(Type::Any))])),
+            (Op::Concat, FunctionType(Box::new(Type::Array(Box::new(Type::Any))), vec![Type::Array(Box::new(Type::Any)), Type::Array(Box::new(Type::Any))])),
+            (Op::Prepend, FunctionType(Box::new(Type::Array(Box::new(Type::Any))), vec![Type::Any, Type::Array(Box::new(Type::Any))])),
+            (Op::Append, FunctionType(Box::new(Type::Array(Box::new(Type::Any))), vec![Type::Array(Box::new(Type::Any)), Type::Any])),
+            (Op::Insert, FunctionType(Box::new(Type::Array(Box::new(Type::Any))), vec![Type::Int, Type::Any, Type::Array(Box::new(Type::Any))])),
             (Op::Tail, FunctionType(Box::new(Type::Array(Box::new(Type::Any))), vec![Type::Array(Box::new(Type::Any))])),
             (Op::Init, FunctionType(Box::new(Type::Array(Box::new(Type::Any))), vec![Type::Array(Box::new(Type::Any))])),
             (Op::Fini, FunctionType(Box::new(Type::Any), vec![Type::Array(Box::new(Type::Any))])),
@@ -171,40 +176,7 @@ impl Parser {
 
         match token.token() {
             TokenType::Constant(c) => Ok(Some(ParseTree::Value(c))),
-            TokenType::Identifier(ident) => {
+            TokenType::Identifier(ident) => Ok(Some(ParseTree::Variable(ident))),
-                match self.get_object_type(&ident).ok_or(
-                        Error::new(format!("undefined identifier {ident}"))
-                            .location(token.line, token.location))? {
-                    Type::Function(f) => {
-                        let f = f.clone();
-                        let args = self.get_args(tokens, f.1.len())?;
-
-                        if args.len() < f.1.len() {
-                            let mut counter = 0;
-                            let func_args: Vec<Type> = f.1.iter().skip(args.len()).cloned().collect();
-                            let (names, types): (Vec<String>, Vec<Type>) = func_args
-                                .into_iter()
-                                .map(|t| {
-                                    counter += 1;
-                                    (format!("{counter}"), t)
-                                }).unzip();
-                            let function_type = FunctionType(f.0.clone(), types);
-
-                            Ok(Some(ParseTree::Value(Value::Function(Function::lambda(
-                                function_type,
-                                names.clone(),
-                                Box::new(ParseTree::FunctionCall(ident,
-                                    vec![
-                                        args,
-                                        names.into_iter().map(|x| ParseTree::Variable(x)).collect()
-                                    ].concat())))))))
-                        } else {
-                            Ok(Some(ParseTree::FunctionCall(ident, args)))
-                        }
-                    }
-                    _ => Ok(Some(ParseTree::Variable(ident))),
-                }
-            },
             TokenType::Operator(op) => match op {
                 Op::OpenArray => {
                     let mut depth = 1;
@@ -238,7 +210,7 @@ impl Parser {
 
                     let tree = trees.into_iter().fold(
                         ParseTree::Value(Value::Array(Type::Any, vec![])),
-                        |acc, x| ParseTree::Operator(Op::Add, vec![acc, x.clone()]),
+                        |acc, x| ParseTree::Operator(Op::Append, vec![acc, x.clone()]),
                     );
 
                     Ok(Some(tree))
@@ -248,7 +220,7 @@ impl Parser {
 
                     // take tokens until we reach the end of this array
                     // if we don't collect them here it causes rust to overflow computing the types
-                    let array_tokens = tokens.by_ref().take_while(|t| match t {
+                    let tokens = tokens.by_ref().take_while(|t| match t {
                         Ok(t) => match t.token() {
                             TokenType::Operator(Op::OpenStatement) => {
                                 depth += 1;
@@ -263,22 +235,59 @@ impl Parser {
                         _ => true,
                     }).collect::<Result<Vec<_>, Error>>()?;
 
-                    let array_tokens = array_tokens
+                    let mut tokens = tokens
                         .into_iter()
                         .map(|t| Ok(t))
                         .collect::<Vec<Result<Token, Error>>>()
                         .into_iter()
                         .peekable();
 
-                    let trees: Vec<ParseTree> = self.clone().trees(array_tokens)
+                    if let Some(Ok(Some(Type::Function(f)))) = tokens.peek()
-                        .collect::<Result<_, Error>>()?;
+                        .map(|t| t.clone().and_then(|t| match t.token() {
+                            TokenType::Identifier(ident) =>
+                                Ok(Some(self.get_object_type(&ident).ok_or(
+                                    Error::new(format!("undefined identifier {ident}"))
+                                        .location(token.line, token.location))?)),
+                            _ => Ok(None),
+                        }))
+                    {
+                        let token = tokens.next().unwrap().unwrap();
+                        let params: Vec<ParseTree> = self.clone().trees(tokens).collect::<Result<_, Error>>()?;
 
-                    let tree = trees.into_iter().fold(
+                        match params.len().cmp(&f.1.len()) {
-                        ParseTree::Nop,
+                            Ordering::Equal => Ok(Some(ParseTree::FunctionCall(token.lexeme, params))),
-                        |acc, x| ParseTree::Operator(Op::Compose, vec![acc, x.clone()]),
+                            Ordering::Greater => Err(Error::new(format!("too many arguments to {}", token.lexeme)).location(token.line, token.location)),
-                    );
+                            Ordering::Less => {
+                                let mut counter = 0;
+                                let func_args: Vec<Type> = f.1.iter().skip(params.len()).cloned().collect();
+                                let (names, types): (Vec<String>, Vec<Type>) = func_args
+                                    .into_iter()
+                                    .map(|t| {
+                                        counter += 1;
+                                        (format!("{counter}"), t)
+                                    }).unzip();
+                                let function_type = FunctionType(f.0.clone(), types);
+    
+                                Ok(Some(ParseTree::Value(Value::Function(Function::lambda(
+                                    function_type,
+                                    names.clone(),
+                                    Box::new(ParseTree::FunctionCall(token.lexeme,
+                                        vec![
+                                            params,
+                                            names.into_iter().map(|x| ParseTree::Variable(x)).collect()
+                                        ].concat())))))))
+                            }
+                        }
+                    } else {
+                        let trees: Vec<ParseTree> = self.clone().trees(tokens).collect::<Result<_, Error>>()?;
 
-                    Ok(Some(tree))
+                        let tree = trees.into_iter().fold(
+                            ParseTree::Nop,
+                            |acc, x| ParseTree::Operator(Op::Compose, vec![acc, x.clone()]),
+                        );
+
+                        Ok(Some(tree))
+                    }
                 },
                 Op::Equ => {
                     let token = tokens.next()
@@ -356,10 +365,6 @@ impl Parser {
                 },
                 Op::LambdaDefine(arg_count) => Ok(Some(ParseTree::LambdaDefinition(self.parse_lambda_definition(tokens, arg_count)?))),
                 Op::Empty => Ok(Some(ParseTree::Value(Value::Array(Type::Any, vec![])))),
-                Op::NonCall => {
-                    let name = Self::get_identifier(tokens.next())?;
-                    Ok(Some(ParseTree::NonCall(name)))
-                },
                 Op::If => {
                     let cond = self.parse(tokens)?
                         .ok_or(Error::new("? statement requires a condition".into())
@@ -372,21 +377,21 @@ impl Parser {
                 },
                 Op::IfElse => {
                     let cond = self.parse(tokens)?
-                    .ok_or(Error::new("?? statement requires a condition".into())
+                        .ok_or(Error::new("?? statement requires a condition".into())
-                        .location(token.line, token.location.clone()))?;
+                            .location(token.line, token.location.clone()))?;
                     let truebranch = self.parse(tokens)?
-                    .ok_or(Error::new("?? statement requires a branch".into())
+                        .ok_or(Error::new("?? statement requires a branch".into())
-                        .location(token.line, token.location.clone()))?;
+                            .location(token.line, token.location.clone()))?;
                     let falsebranch = self.parse(tokens)?
-                    .ok_or(Error::new("?? statement requires a false branch".into())
+                        .ok_or(Error::new("?? statement requires a false branch".into())
-                        .location(token.line, token.location))?;
+                            .location(token.line, token.location))?;
     
                     Ok(Some(ParseTree::IfElse(
                         Box::new(cond), Box::new(truebranch), Box::new(falsebranch))))
                 },
                 Op::Export => {
                     let token = tokens.next()
-                        .ok_or(Error::new("export expects one argument of [String], but found nothing".into())
+                        .ok_or(Error::new("export expects an identifer or multiple inside of parens".into())
                             .location(token.line, token.location.clone()))??;
 
                     let names = match token.token() {

src/tokenizer.rs

@@ -7,6 +7,8 @@ use crate::error::Error;
 use super::Value;
 use std::io::BufRead;
 use std::ops::Range;
+use std::fmt;
+use std::fmt::Formatter;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Op {
@@ -17,6 +19,7 @@ pub enum Op {
     FloorDiv,
     Exp,
     Equ,
+    Neg,
     Mod,
     LazyEqu,
     TypeDeclaration,
@@ -42,6 +45,10 @@ pub enum Op {
     Print,
     OpenArray,
     CloseArray,
+    Concat,
+    Prepend,
+    Append,
+    Insert,
     OpenStatement,
     CloseStatement,
     Empty,
@@ -52,7 +59,62 @@ pub enum Op {
     Init,
     Fini,
     Export,
-    NonCall,
+}
+
+impl fmt::Display for Op {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let s = match self {
+            Op::Add => "+",
+            Op::Sub => "-",
+            Op::Mul => "*",
+            Op::Div => "/",
+            Op::FloorDiv => "//",
+            Op::Exp => "**",
+            Op::Equ => "=",
+            Op::Neg => "_",
+            Op::Mod => "%",
+            Op::LazyEqu => ".",
+            Op::TypeDeclaration => "?.",
+            Op::FunctionDefine(_n) => ":",
+            Op::FunctionDeclare(_n) => "?:",
+            Op::LambdaDefine(_n) => ";",
+            Op::Arrow => "->",
+            Op::Compose => "~",
+            Op::Id => ",",
+            Op::If => "?",
+            Op::IfElse => "??",
+            Op::GreaterThan => ">",
+            Op::LessThan => "<",
+            Op::EqualTo => "==",
+            Op::NotEqualTo => "!=",
+            Op::GreaterThanOrEqualTo => ">=",
+            Op::LessThanOrEqualTo => ">=",
+            Op::Not => "!",
+            Op::IntCast => "int",
+            Op::FloatCast => "float",
+            Op::BoolCast => "bool",
+            Op::StringCast => "string",
+            Op::Print => "print",
+            Op::OpenArray => "[",
+            Op::CloseArray => "]",
+            Op::Concat => "++",
+            Op::Prepend => "[+",
+            Op::Append => "+]",
+            Op::Insert => "[+]",
+            Op::OpenStatement => "(",
+            Op::CloseStatement => ")",
+            Op::Empty => "empty",
+            Op::And => "&&",
+            Op::Or => "||",
+            Op::Head => "head",
+            Op::Tail => "tail",
+            Op::Init => "init",
+            Op::Fini => "fini",
+            Op::Export => "export",
+        };
+
+        write!(f, "{s}")
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -71,9 +133,9 @@ impl TokenType {
             "true"  => TokenType::Constant(Value::Bool(true)),
             "false" => TokenType::Constant(Value::Bool(false)),
             "nil" => TokenType::Constant(Value::Nil),
-            "int"    => TokenType::Operator(Op::IntCast),
+            "int" => TokenType::Operator(Op::IntCast),
-            "float"  => TokenType::Operator(Op::FloatCast),
+            "float" => TokenType::Operator(Op::FloatCast),
-            "bool"   => TokenType::Operator(Op::BoolCast),
+            "bool" => TokenType::Operator(Op::BoolCast),
             "string" => TokenType::Operator(Op::StringCast),
             "print" => TokenType::Operator(Op::Print),
             "empty" => TokenType::Operator(Op::Empty),
@@ -83,7 +145,7 @@ impl TokenType {
             "fini" => TokenType::Operator(Op::Fini),
             "export" => TokenType::Operator(Op::Export),
 
-            // Types
+            // Built-in Types
             "Any" => TokenType::Type(Type::Any),
             "Int" => TokenType::Type(Type::Int),
             "Float" => TokenType::Type(Type::Float),
@@ -189,6 +251,7 @@ impl<R: BufRead> Tokenizer<R> {
             ("**", Op::Exp),
             ("%", Op::Mod),
             ("=", Op::Equ),
+            ("_", Op::Neg),
             (".", Op::LazyEqu),
             ("?.", Op::TypeDeclaration),
             (":", Op::FunctionDefine(1)),
@@ -207,12 +270,15 @@ impl<R: BufRead> Tokenizer<R> {
             ("!=", Op::NotEqualTo),
             ("[", Op::OpenArray),
             ("]", Op::CloseArray),
+            ("++", Op::Concat),
+            ("[+", Op::Prepend),
+            ("+]", Op::Append),
+            ("[+]", Op::Insert),
             ("(", Op::OpenStatement),
             (")", Op::CloseStatement),
             ("!", Op::Not),
             ("&&", Op::And),
             ("||", Op::Or),
-            ("\\", Op::NonCall),
         ]);
 
         let c = if let Some(c) = self.next_char() {
@@ -224,7 +290,7 @@ impl<R: BufRead> Tokenizer<R> {
         if c.is_alphanumeric() {
             let mut token = String::from(c);
 
-            while let Some(c) = self.next_char_if(|&c| c.is_alphanumeric() || c == '.' || c == '\'') {
+            while let Some(c) = self.next_char_if(|&c| c.is_alphanumeric() || c == '.' || c == '\'' || c == '_') {
                 token.push(c);
             }
 
@@ -365,4 +431,19 @@ impl<R: BufRead> Iterator for Tokenizer<R> {
     fn next(&mut self) -> Option<Self::Item> {
         self.tokenize().transpose()
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    #[test]
+    fn meow() {
+        let program = "[+] 0 1 [2 3]";
+
+        let tokens: Vec<_> = Tokenizer::new(Arc::new(Mutex::new(CodeIter::new(Cursor::new(program))))).collect();
+
+        println!("{tokens:#?}");
+    }
 }