Started new kv impl with support for mutable cells, just the basic interpreter. Going to add the lazy bytecode interperter next
This commit is contained in:
350
kv/src/ast.rs
Normal file
350
kv/src/ast.rs
Normal file
@@ -0,0 +1,350 @@
|
||||
use std::fmt;
|
||||
use std::rc::Rc;
|
||||
use std::cell::RefCell;
|
||||
use std::convert::From;
|
||||
|
||||
impl From<i32> for Form { fn from(item: i32) -> Self { Form::Int(item) } }
|
||||
impl From<bool> for Form { fn from(item: bool) -> Self { Form::Bool(item) } }
|
||||
// todo, strings not symbols?
|
||||
impl From<String> for Form { fn from(item: String) -> Self { Form::Symbol(item) } }
|
||||
impl From<&str> for Form { fn from(item: &str) -> Self { Form::Symbol(item.to_owned()) } }
|
||||
|
||||
impl<A: Into<Form>, B: Into<Form>> From<(A, B)> for Form {
|
||||
fn from(item: (A, B)) -> Self {
|
||||
Form::Pair(Rc::new(item.0.into()), Rc::new(item.1.into()))
|
||||
}
|
||||
}
|
||||
|
||||
pub enum PossibleTailCall {
|
||||
Result(Rc<Form>),
|
||||
TailCall(Rc<Form>, Rc<Form>),
|
||||
}
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub enum Form {
|
||||
Nil,
|
||||
Int(i32),
|
||||
Bool(bool),
|
||||
Symbol(String),
|
||||
Cell(RefCell<Rc<Form>>),
|
||||
Pair(Rc<Form>,Rc<Form>),
|
||||
PrimComb(String, fn(Rc<Form>, Rc<Form>) -> PossibleTailCall),
|
||||
DeriComb { se: Rc<Form>, de: Option<String>, params: String, body: Rc<Form> },
|
||||
}
|
||||
impl Form {
|
||||
pub fn truthy(&self) -> bool {
|
||||
match self {
|
||||
Form::Bool(b) => *b,
|
||||
Form::Nil => false,
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
pub fn int(&self) -> Option<i32> {
|
||||
match self {
|
||||
Form::Int(i) => Some(*i),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn sym(&self) -> Option<&str> {
|
||||
match self {
|
||||
Form::Symbol(s) => Some(s),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn car(&self) -> Option<Rc<Form>> {
|
||||
match self {
|
||||
Form::Pair(car, _cdr) => Some(Rc::clone(car)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn cdr(&self) -> Option<Rc<Form>> {
|
||||
match self {
|
||||
Form::Pair(_car, cdr) => Some(Rc::clone(cdr)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn append(&self, x: Rc<Form>) -> Option<Form> {
|
||||
match self {
|
||||
Form::Pair(car, cdr) => cdr.append(x).map(|x| Form::Pair(Rc::clone(car), Rc::new(x))),
|
||||
Form::Nil => Some(Form::Pair(x, Rc::new(Form::Nil))),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl fmt::Display for Form {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Form::Nil => write!(f, "nil"),
|
||||
Form::Int(i) => write!(f, "{i}"),
|
||||
Form::Bool(b) => write!(f, "{b}"),
|
||||
Form::Symbol(s) => write!(f, "{s}"),
|
||||
Form::Cell(c) => write!(f, "@{}", c.borrow()),
|
||||
Form::Pair(car, cdr) => {
|
||||
write!(f, "({}", car)?;
|
||||
let mut traverse: Rc<Form> = Rc::clone(cdr);
|
||||
loop {
|
||||
match &*traverse {
|
||||
Form::Pair(ref carp, ref cdrp) => {
|
||||
write!(f, " {}", carp)?;
|
||||
traverse = Rc::clone(cdrp);
|
||||
},
|
||||
Form::Nil => {
|
||||
write!(f, ")")?;
|
||||
return Ok(());
|
||||
},
|
||||
x => {
|
||||
write!(f, ". {x})")?;
|
||||
return Ok(());
|
||||
},
|
||||
}
|
||||
}
|
||||
},
|
||||
Form::PrimComb(name, _f) => write!(f, "<{name}>"),
|
||||
Form::DeriComb { se, de, params, body } => {
|
||||
write!(f, "<{} {} {}>", de.as_ref().unwrap_or(&"".to_string()), params, body)
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn eval(e: Rc<Form>, f: Rc<Form>) -> Rc<Form> {
|
||||
let mut e = e;
|
||||
let mut x = Option::Some(f);
|
||||
loop {
|
||||
let cur = x.take().unwrap();
|
||||
match *cur {
|
||||
Form::Symbol(ref s) => {
|
||||
let mut t = e;
|
||||
while s != t.car().unwrap().car().unwrap().sym().unwrap() {
|
||||
t = t.cdr().unwrap();
|
||||
}
|
||||
return t.car().unwrap().cdr().unwrap();
|
||||
},
|
||||
Form::Pair(ref c, ref p) => {
|
||||
let comb = eval(Rc::clone(&e), Rc::clone(c));
|
||||
match *comb {
|
||||
Form::PrimComb(ref _n, ref f) => match f(e, Rc::clone(p)) {
|
||||
PossibleTailCall::Result(r) => return r,
|
||||
PossibleTailCall::TailCall(ne, nx) => {
|
||||
e = ne;
|
||||
x = Some(nx);
|
||||
},
|
||||
},
|
||||
Form::DeriComb{ref se, ref de, ref params, ref body } => {
|
||||
let mut new_e = Rc::clone(se);
|
||||
if let Some(de) = de {
|
||||
new_e = assoc(de, Rc::clone(&e), new_e);
|
||||
}
|
||||
new_e = assoc(params, Rc::clone(p), new_e);
|
||||
// always a tail call
|
||||
e = new_e;
|
||||
x = Some(Rc::clone(body));
|
||||
},
|
||||
_ => panic!("Tried to call not a Prim/DeriComb {:?}", comb),
|
||||
}
|
||||
},
|
||||
_ => return cur,
|
||||
}
|
||||
}
|
||||
}
|
||||
fn assoc(k: &str, v: Rc<Form>, l: Rc<Form>) -> Rc<Form> {
|
||||
Rc::new(Form::Pair(
|
||||
Rc::new(Form::Pair(
|
||||
Rc::new(Form::Symbol(k.to_owned())),
|
||||
v)),
|
||||
l))
|
||||
}
|
||||
fn assoc_vec(kvs: Vec<(&str, Rc<Form>)>) -> Rc<Form> {
|
||||
let mut to_ret = Rc::new(Form::Nil);
|
||||
for (k, v) in kvs {
|
||||
to_ret = assoc(k, v, to_ret);
|
||||
}
|
||||
to_ret
|
||||
}
|
||||
|
||||
pub fn root_env() -> Rc<Form> {
|
||||
assoc_vec(vec![
|
||||
("eval", Rc::new(Form::PrimComb("eval".to_owned(), |e, p| {
|
||||
let b = eval(Rc::clone(&e), p.car().unwrap());
|
||||
let e = eval(e, p.cdr().unwrap().car().unwrap());
|
||||
PossibleTailCall::TailCall(e, b)
|
||||
}))),
|
||||
// (vau de params body)
|
||||
("vau", Rc::new(Form::PrimComb("vau".to_owned(), |e, p| {
|
||||
let de = p.car().unwrap().sym().map(|s| s.to_owned());
|
||||
let params = p.cdr().unwrap().car().unwrap().sym().unwrap().to_owned();
|
||||
let body = p.cdr().unwrap().cdr().unwrap().car().unwrap();
|
||||
|
||||
PossibleTailCall::Result(Rc::new(Form::DeriComb { se: e, de, params, body }))
|
||||
}))),
|
||||
("=", Rc::new(Form::PrimComb("=".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap());
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap());
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(a == b)))
|
||||
}))),
|
||||
("<", Rc::new(Form::PrimComb("<".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap());
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap());
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(a.int().unwrap() < b.int().unwrap())))
|
||||
}))),
|
||||
(">", Rc::new(Form::PrimComb(">".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap());
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap());
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(a.int().unwrap() > b.int().unwrap())))
|
||||
}))),
|
||||
("<=", Rc::new(Form::PrimComb("<=".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap());
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap());
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(a.int().unwrap() <= b.int().unwrap())))
|
||||
}))),
|
||||
(">=", Rc::new(Form::PrimComb(">=".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap());
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap());
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(a.int().unwrap() >= b.int().unwrap())))
|
||||
}))),
|
||||
("if", Rc::new(Form::PrimComb("if".to_owned(), |e, p| {
|
||||
if eval(Rc::clone(&e), p.car().unwrap()).truthy() {
|
||||
PossibleTailCall::TailCall(e, p.cdr().unwrap().car().unwrap())
|
||||
} else {
|
||||
PossibleTailCall::TailCall(e, p.cdr().unwrap().cdr().unwrap().car().unwrap())
|
||||
}
|
||||
}))),
|
||||
|
||||
("cell", Rc::new(Form::PrimComb("cell".to_owned(), |e, p| {
|
||||
let x = eval(Rc::clone(&e), p.car().unwrap());
|
||||
PossibleTailCall::Result(Rc::new(Form::Cell(RefCell::new(x))))
|
||||
}))),
|
||||
("set", Rc::new(Form::PrimComb("set".to_owned(), |e, p| {
|
||||
match &*eval(Rc::clone(&e), p.car().unwrap()) {
|
||||
Form::Cell(c) => PossibleTailCall::Result(c.replace(eval(Rc::clone(&e), p.cdr().unwrap().car().unwrap()))),
|
||||
_ => panic!("set on not cell"),
|
||||
}
|
||||
}))),
|
||||
("get", Rc::new(Form::PrimComb("get".to_owned(), |e, p| {
|
||||
match &*eval(Rc::clone(&e), p.car().unwrap()) {
|
||||
Form::Cell(c) => PossibleTailCall::Result(Rc::clone(&c.borrow())),
|
||||
_ => panic!("get on not cell"),
|
||||
}
|
||||
}))),
|
||||
|
||||
("cons", Rc::new(Form::PrimComb("cons".to_owned(), |e, p| {
|
||||
let h = eval(Rc::clone(&e), p.car().unwrap());
|
||||
let t = eval(e, p.cdr().unwrap().car().unwrap());
|
||||
PossibleTailCall::Result(Rc::new(Form::Pair(h, t)))
|
||||
}))),
|
||||
("car", Rc::new(Form::PrimComb("car".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(eval(Rc::clone(&e), p.car().unwrap()).car().unwrap())
|
||||
}))),
|
||||
("cdr", Rc::new(Form::PrimComb("cdr".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(eval(Rc::clone(&e), p.car().unwrap()).cdr().unwrap())
|
||||
}))),
|
||||
("quote", Rc::new(Form::PrimComb("quote".to_owned(), |_e, p| {
|
||||
PossibleTailCall::Result(p.car().unwrap())
|
||||
}))),
|
||||
|
||||
("debug", Rc::new(Form::PrimComb("debug".to_owned(), |e, p| {
|
||||
//println!("Debug: {:?}", eval(Rc::clone(&e), p.car().unwrap()));
|
||||
println!("Debug: {}", eval(Rc::clone(&e), p.car().unwrap()));
|
||||
PossibleTailCall::TailCall(e, p.cdr().unwrap().car().unwrap())
|
||||
}))),
|
||||
("assert", Rc::new(Form::PrimComb("assert".to_owned(), |e, p| {
|
||||
let thing = eval(Rc::clone(&e), p.car().unwrap());
|
||||
if !thing.truthy() {
|
||||
println!("Assert failed: {:?}", thing);
|
||||
}
|
||||
assert!(thing.truthy());
|
||||
PossibleTailCall::TailCall(e, p.cdr().unwrap().car().unwrap())
|
||||
}))),
|
||||
|
||||
("+", Rc::new(Form::PrimComb("+".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a + b)))
|
||||
}))),
|
||||
("-", Rc::new(Form::PrimComb("-".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a - b)))
|
||||
}))),
|
||||
("*", Rc::new(Form::PrimComb("*".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a * b)))
|
||||
}))),
|
||||
("/", Rc::new(Form::PrimComb("/".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a / b)))
|
||||
}))),
|
||||
("%", Rc::new(Form::PrimComb("%".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a % b)))
|
||||
}))),
|
||||
("&", Rc::new(Form::PrimComb("&".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a & b)))
|
||||
}))),
|
||||
("|", Rc::new(Form::PrimComb("|".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a | b)))
|
||||
}))),
|
||||
("^", Rc::new(Form::PrimComb("^".to_owned(), |e, p| {
|
||||
let a = eval(Rc::clone(&e), p.car().unwrap()).int().unwrap();
|
||||
let b = eval(e, p.cdr().unwrap().car().unwrap()).int().unwrap();
|
||||
PossibleTailCall::Result(Rc::new(Form::Int(a ^ b)))
|
||||
}))),
|
||||
|
||||
("comb?", Rc::new(Form::PrimComb("comb?".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(match &*eval(e, p.car().unwrap()) {
|
||||
Form::PrimComb(_n, _f) => true,
|
||||
Form::DeriComb { .. } => true,
|
||||
_ => false,
|
||||
})))
|
||||
}))),
|
||||
("cell?", Rc::new(Form::PrimComb("cell?".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(match &*eval(e, p.car().unwrap()) {
|
||||
Form::Cell(_c) => true,
|
||||
_ => false,
|
||||
})))
|
||||
}))),
|
||||
("pair?", Rc::new(Form::PrimComb("pair?".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(match &*eval(e, p.car().unwrap()) {
|
||||
Form::Pair(_a,_b) => true,
|
||||
_ => false,
|
||||
})))
|
||||
}))),
|
||||
("symbol?", Rc::new(Form::PrimComb("symbol?".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(match &*eval(e, p.car().unwrap()) {
|
||||
Form::Symbol(_) => true,
|
||||
_ => false,
|
||||
})))
|
||||
}))),
|
||||
("int?", Rc::new(Form::PrimComb("int?".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(match &*eval(e, p.car().unwrap()) {
|
||||
Form::Int(_) => true,
|
||||
_ => false,
|
||||
})))
|
||||
}))),
|
||||
// maybe bool? but also could be derived. Nil def
|
||||
("bool?", Rc::new(Form::PrimComb("bool?".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(match &*eval(e, p.car().unwrap()) {
|
||||
Form::Bool(_) => true,
|
||||
_ => false,
|
||||
})))
|
||||
}))),
|
||||
("nil?", Rc::new(Form::PrimComb("nil?".to_owned(), |e, p| {
|
||||
PossibleTailCall::Result(Rc::new(Form::Bool(match &*eval(e, p.car().unwrap()) {
|
||||
Form::Nil => true,
|
||||
_ => false,
|
||||
})))
|
||||
}))),
|
||||
|
||||
// consts
|
||||
("true", Rc::new(Form::Bool(true))),
|
||||
("false", Rc::new(Form::Bool(false))),
|
||||
("nil", Rc::new(Form::Nil)),
|
||||
])
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user