339 lines
14 KiB
Rust
339 lines
14 KiB
Rust
use std::fmt;
|
|
use std::rc::Rc;
|
|
use std::convert::From;
|
|
|
|
// TODO:
|
|
// -extend vau & env logic and SuspendedPair PE with sequence_params & wrap_level
|
|
// -add current-hashes to if
|
|
// -expand combiner_Return_ok with (func ...params) | func doesn't take de and func+params are return ok
|
|
// -add recursive drop redundent veval
|
|
// -mark rec-hash on DeriComb
|
|
// -add compiler
|
|
//
|
|
// -use current fake comb ids instead of hashes
|
|
// -do they have to be added to not-under thing like hashes
|
|
// -make cons work only for SuspendedParam/Env
|
|
|
|
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),
|
|
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::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();
|
|
//println!("Evaluating {:?} in {:?}", cur, e);
|
|
match *cur {
|
|
Form::Symbol(ref s) => {
|
|
let mut t = e;
|
|
//println!("Looking up {} in {:?}", s, t);
|
|
//println!("Looking up {}", s);
|
|
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())
|
|
}
|
|
}))),
|
|
("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,
|
|
})))
|
|
}))),
|
|
("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)),
|
|
])
|
|
}
|
|
|