minneelyyyy/lamm
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: minneelyyyy:dev
Branches Tags
minneelyyyy:main minneelyyyy:dev
..
compare: minneelyyyy:main
Branches Tags
minneelyyyy:dev minneelyyyy:main

1 Commits
dev ... main

Author SHA1 Message Date
minneelyyyy
995be33854 remove workflow 2025-06-28 00:10:28 -04:00
6 changed files with 294 additions and 369 deletions
Expand all files Collapse all files

8
Cargo.lock generated
View File

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

64
README.md
View File

@@ -77,53 +77,43 @@ 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. 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 : inc x + x 1
+ x 1 inc 24 # => 25
(inc 24) # => 25
: sqrt x :. pythag a b sqrt + ** a 2.0 ** b 2.0
** x 0.5 pythag 3 4 # => 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 :::::. ten'args a b c d e f g h i j
[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. 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 # Takes an x of `Any` type
: inc x : inc x + x 1
+ x 1 inc 12 # => 13
(inc 12) # => 13
# Takes an x of `Int` and returns an `Int` # Takes an x of `Int` and returns an `Int`
: inc ?. x Int -> Int : inc ?. x Int -> Int + x 1
+ x 1 inc 9 # => 10
(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. 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 # Applies a function to any value
:. apply : f x :. apply : f x f x
(f x) apply \sqrt 9 # => 3
(apply sqrt 9) # => 3
# Applies a function f which maps an Int to an Int to x # Applies a function f which maps an Int to an Int to x
:. apply'int ?: f Int -> Int ?. x Int -> Int :. apply'int ?: f Int -> Int ?. x Int -> Int f x
(f x) apply'int \sqrt 36 # => 6
(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`. You can pass a function with just it's identifier. 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.
And of course, `:` and `?:` in function prototypes can also be extended depending on the number of arguments the function must take. And off course, `:` and `?:` in function prototypes can also be extended depending on the number of arguments the function must take.
## Branching ## Branching
@@ -181,28 +171,28 @@ Using these, you can build a lot of fundamental functional paradigm functions.
``` ```
:. map : f ?. x [] -> [] :. 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 -> [] :: 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 [] -> [] :. take ?. n Int ?. x [] -> []
?? > n 0 ?? > n 0
[+ head x (take - n 1 tail x) + head x take - n 1 tail x
empty 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 [] -> [] :. 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 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 ## Lambdas

373
src/executor.rs
View File

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

6
src/function.rs
View File

@@ -119,6 +119,12 @@ impl Function {
ParseTree::Value(_) => body, ParseTree::Value(_) => body,
ParseTree::Nop => body, ParseTree::Nop => body,
ParseTree::Export(_) => 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!(), ParseTree::GeneratedFunction(_) => todo!(),
} }
} }

117
src/parser.rs
View File

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

95
src/tokenizer.rs
View File

@@ -7,8 +7,6 @@ use crate::error::Error;
use super::Value; use super::Value;
use std::io::BufRead; use std::io::BufRead;
use std::ops::Range; use std::ops::Range;
use std::fmt;
use std::fmt::Formatter;
#[derive(Debug, Clone, PartialEq, Eq, Hash)] #[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Op { pub enum Op {
@@ -19,7 +17,6 @@ pub enum Op {
FloorDiv, FloorDiv,
Exp, Exp,
Equ, Equ,
Neg,
Mod, Mod,
LazyEqu, LazyEqu,
TypeDeclaration, TypeDeclaration,
@@ -45,10 +42,6 @@ pub enum Op {
Print, Print,
OpenArray, OpenArray,
CloseArray, CloseArray,
Concat,
Prepend,
Append,
Insert,
OpenStatement, OpenStatement,
CloseStatement, CloseStatement,
Empty, Empty,
@@ -59,62 +52,7 @@ pub enum Op {
Init, Init,
Fini, Fini,
Export, 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)] #[derive(Debug, Clone, PartialEq)]
@@ -133,9 +71,9 @@ impl TokenType {
"true" => TokenType::Constant(Value::Bool(true)), "true" => TokenType::Constant(Value::Bool(true)),
"false" => TokenType::Constant(Value::Bool(false)), "false" => TokenType::Constant(Value::Bool(false)),
"nil" => TokenType::Constant(Value::Nil), "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), "string" => TokenType::Operator(Op::StringCast),
"print" => TokenType::Operator(Op::Print), "print" => TokenType::Operator(Op::Print),
"empty" => TokenType::Operator(Op::Empty), "empty" => TokenType::Operator(Op::Empty),
@@ -145,7 +83,7 @@ impl TokenType {
"fini" => TokenType::Operator(Op::Fini), "fini" => TokenType::Operator(Op::Fini),
"export" => TokenType::Operator(Op::Export), "export" => TokenType::Operator(Op::Export),
// Built-in Types // Types
"Any" => TokenType::Type(Type::Any), "Any" => TokenType::Type(Type::Any),
"Int" => TokenType::Type(Type::Int), "Int" => TokenType::Type(Type::Int),
"Float" => TokenType::Type(Type::Float), "Float" => TokenType::Type(Type::Float),
@@ -251,7 +189,6 @@ impl<R: BufRead> Tokenizer<R> {
("**", Op::Exp), ("**", Op::Exp),
("%", Op::Mod), ("%", Op::Mod),
("=", Op::Equ), ("=", Op::Equ),
("_", Op::Neg),
(".", Op::LazyEqu), (".", Op::LazyEqu),
("?.", Op::TypeDeclaration), ("?.", Op::TypeDeclaration),
(":", Op::FunctionDefine(1)), (":", Op::FunctionDefine(1)),
@@ -270,15 +207,12 @@ impl<R: BufRead> Tokenizer<R> {
("!=", Op::NotEqualTo), ("!=", Op::NotEqualTo),
("[", Op::OpenArray), ("[", Op::OpenArray),
("]", Op::CloseArray), ("]", Op::CloseArray),
("++", Op::Concat),
("[+", Op::Prepend),
("+]", Op::Append),
("[+]", Op::Insert),
("(", Op::OpenStatement), ("(", Op::OpenStatement),
(")", Op::CloseStatement), (")", Op::CloseStatement),
("!", Op::Not), ("!", Op::Not),
("&&", Op::And), ("&&", Op::And),
("||", Op::Or), ("||", Op::Or),
("\\", Op::NonCall),
]); ]);
let c = if let Some(c) = self.next_char() { let c = if let Some(c) = self.next_char() {
@@ -290,7 +224,7 @@ impl<R: BufRead> Tokenizer<R> {
if c.is_alphanumeric() { if c.is_alphanumeric() {
let mut token = String::from(c); let mut token = String::from(c);
while let Some(c) = self.next_char_if(|&c| c.is_alphanumeric() || c == '.' || c == '\'' || c == '_') { while let Some(c) = self.next_char_if(|&c| c.is_alphanumeric() || c == '.' || c == '\'') {
token.push(c); token.push(c);
} }
@@ -432,18 +366,3 @@ impl<R: BufRead> Iterator for Tokenizer<R> {
self.tokenize().transpose() 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:#?}");
}
}