From 15cab8799d816e50731e87b5c56b56aa2a78058b Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Thu, 13 Jul 2023 22:52:49 -0400 Subject: [PATCH] swap to single struct wrapper scaffolding --- kv/src/opt.rs | 221 +++++++++++++++++++++++--------------------------- 1 file changed, 102 insertions(+), 119 deletions(-) diff --git a/kv/src/opt.rs b/kv/src/opt.rs index 0107f19..1bed6bb 100644 --- a/kv/src/opt.rs +++ b/kv/src/opt.rs @@ -8,7 +8,13 @@ use crate::eval::{FormT,Cont,Cursor,PrimCombI}; use crate::basic::Form; #[derive(Debug, Eq, PartialEq)] -pub enum OptForm { +pub struct OptForm { + inner: OptFormInner, + code_ptr: usize +} + +#[derive(Debug, Eq, PartialEq)] +pub enum OptFormInner { Nil, Int(i32), Bool(bool), @@ -18,10 +24,6 @@ pub enum OptForm { PrimComb { eval_limit: i32, ins: PrimCombI }, DeriComb { se: Rc, de: Option, params: String, body: Rc, code: Option>>> }, ContComb(Cont), - - // Hmm this needs to wrap both outside and inside, as inside can still emit code... - // or do we need to wrap everything b/c side effects (mutation and assert, at least)... - CodeForm { code_offset: usize, code: Rc>>, inner_value: Rc }, } #[derive(Debug, Eq, PartialEq)] pub enum ByteCode { @@ -30,94 +32,91 @@ pub enum ByteCode { impl fmt::Display for OptForm { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - OptForm::Nil => write!(f, "nil"), - OptForm::Int(i) => write!(f, "{i}"), - OptForm::Bool(b) => write!(f, "{b}"), - OptForm::Symbol(s) => write!(f, "{s}"), - OptForm::Cell(c) => write!(f, "@{}", c.borrow()), - OptForm::Pair(car, cdr) => { + match &self.inner { + OptFormInner::Nil => write!(f, "nil"), + OptFormInner::Int(i) => write!(f, "{i}"), + OptFormInner::Bool(b) => write!(f, "{b}"), + OptFormInner::Symbol(s) => write!(f, "{s}"), + OptFormInner::Cell(c) => write!(f, "@{}", c.borrow()), + OptFormInner::Pair(car, cdr) => { write!(f, "({}", car)?; let mut traverse: Rc = Rc::clone(cdr); loop { - match &*traverse { - OptForm::Pair(ref carp, ref cdrp) => { + match &traverse.inner { + OptFormInner::Pair(ref carp, ref cdrp) => { write!(f, " {}", carp)?; traverse = Rc::clone(cdrp); }, - OptForm::Nil => { + OptFormInner::Nil => { write!(f, ")")?; return Ok(()); }, x => { - write!(f, ". {x})")?; + write!(f, ". {})", traverse)?; return Ok(()); }, } } }, - OptForm::PrimComb { eval_limit, ins } => write!(f, "<{eval_limit}> - {ins:?}"), - OptForm::DeriComb { se: _, de, params, body, code: _ } => { + OptFormInner::PrimComb { eval_limit, ins } => write!(f, "<{eval_limit}> - {ins:?}"), + OptFormInner::DeriComb { se: _, de, params, body, code: _ } => { write!(f, "<{} {} {}>", de.as_ref().unwrap_or(&"".to_string()), params, body) }, - OptForm::ContComb(_) => write!(f, ""), - OptForm::CodeForm { code_offset, inner_value, .. } => write!(f, "~code{code_offset}~({inner_value})"), + OptFormInner::ContComb(_) => write!(f, ""), } } } impl From<&Form> for Rc { fn from(x: &Form) -> Self { - Rc::new(match x { - Form::Nil => OptForm::Nil, - Form::Int(i) => OptForm::Int(*i), - Form::Bool(b) => OptForm::Bool(*b), - Form::Symbol(s) => OptForm::Symbol(s.to_owned()), + match x { + Form::Nil => OptForm::new(OptFormInner::Nil), + Form::Int(i) => OptForm::new(OptFormInner::Int(*i)), + Form::Bool(b) => OptForm::new(OptFormInner::Bool(*b)), + Form::Symbol(s) => OptForm::new(OptFormInner::Symbol(s.to_owned())), Form::Cell(cell) => panic!("bad"), - Form::Pair(car,cdr) => OptForm::Pair((&**car).into(), (&**cdr).into()), - Form::PrimComb { eval_limit, ins } => OptForm::PrimComb { eval_limit: *eval_limit, ins: *ins }, + Form::Pair(car,cdr) => OptForm::new(OptFormInner::Pair((&**car).into(), (&**cdr).into())), + Form::PrimComb { eval_limit, ins } => OptForm::new(OptFormInner::PrimComb { eval_limit: *eval_limit, ins: *ins }), Form::DeriComb { .. } => panic!("bad"), Form::ContComb(c) => panic!("bad"), - }) + } } } impl OptForm { + fn new(inner: OptFormInner) -> Rc { Rc::new(OptForm { inner, code_ptr: 0 }) } fn nil() -> Rc { - Rc::new(OptForm::Nil) + OptForm::new(OptFormInner::Nil) } fn truthy(&self) -> bool { - match self { - OptForm::Bool(b) => *b, - OptForm::Nil => false, - OptForm::CodeForm { inner_value, .. } => inner_value.truthy(), - _ => true, + match &self.inner { + OptFormInner::Bool(b) => *b, + OptFormInner::Nil => false, + _ => true, } } fn int(&self) -> Option { - match self { - OptForm::Int(i) => Some(*i), - OptForm::CodeForm { inner_value, .. } => inner_value.int(), - _ => None, + match &self.inner { + OptFormInner::Int(i) => Some(*i), + _ => None, } } fn append(&self, x: Rc) -> Option> { - match self { - OptForm::Pair(car, cdr) => cdr.append(x).map(|x| Rc::new(OptForm::Pair(Rc::clone(car), x))), - OptForm::Nil => Some(Rc::new(OptForm::Pair(x, Rc::new(OptForm::Nil)))), - OptForm::CodeForm { inner_value, .. } => inner_value.append(x), + match &self.inner { + OptFormInner::Pair(car, cdr) => cdr.append(x).map(|x| OptForm::new(OptFormInner::Pair(Rc::clone(car), x))), + OptFormInner::Nil => Some(OptForm::new(OptFormInner::Pair(x, OptForm::new(OptFormInner::Nil )))), _ => None, } } pub fn congruent(&self, other: &Form) -> bool { match other { - Form::Nil => *self == OptForm::Nil, - Form::Int(i) => *self == OptForm::Int(*i), - Form::Bool(b) => *self == OptForm::Bool(*b), - Form::Symbol(s) => *self == OptForm::Symbol(s.to_owned()), + Form::Nil => self.inner == OptFormInner::Nil, + Form::Int(i) => self.inner == OptFormInner::Int(*i), + Form::Bool(b) => self.inner == OptFormInner::Bool(*b), + Form::Symbol(s) => self.inner == OptFormInner::Symbol(s.to_owned()), Form::Cell(cell) => panic!("bad"), - Form::Pair(car,cdr) => match self { OptForm::Pair(carp, cdrp) => carp.congruent(car) && cdrp.congruent(cdr), _ => false }, - Form::PrimComb { eval_limit, ins } => *self == OptForm::PrimComb { eval_limit: *eval_limit, ins: *ins }, + Form::Pair(car,cdr) => match &self.inner { OptFormInner::Pair(carp, cdrp) => carp.congruent(car) && cdrp.congruent(cdr), _ => false }, + Form::PrimComb { eval_limit, ins } => self.inner == OptFormInner::PrimComb { eval_limit: *eval_limit, ins: *ins }, Form::DeriComb { .. } => panic!("bad"), Form::ContComb(c) => panic!("bad"), } @@ -126,46 +125,41 @@ impl OptForm { impl FormT for OptForm { fn sym(&self) -> Option<&str> { - match self { - OptForm::Symbol(s) => Some(s), - OptForm::CodeForm { inner_value, .. } => inner_value.sym(), + match &self.inner { + OptFormInner::Symbol(s) => Some(s), _ => None, } } fn pair(&self) -> Option<(Rc,Rc)> { - match self { - OptForm::Pair(car, cdr) => Some((Rc::clone(car),Rc::clone(cdr))), - OptForm::CodeForm { inner_value, .. } => inner_value.pair(), + match &self.inner { + OptFormInner::Pair(car, cdr) => Some((Rc::clone(car),Rc::clone(cdr))), _ => None, } } fn car(&self) -> Option> { - match self { - OptForm::Pair(car, _cdr) => Some(Rc::clone(car)), - OptForm::CodeForm { inner_value, .. } => inner_value.car(), + match &self.inner { + OptFormInner::Pair(car, _cdr) => Some(Rc::clone(car)), _ => None, } } fn cdr(&self) -> Option> { - match self { - OptForm::Pair(_car, cdr) => Some(Rc::clone(cdr)), - OptForm::CodeForm { inner_value, .. } => inner_value.cdr(), + match &self.inner { + OptFormInner::Pair(_car, cdr) => Some(Rc::clone(cdr)), _ => None, } } fn is_nil(&self) -> bool { - match self { - OptForm::Nil => true, - OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), + match &self.inner { + OptFormInner::Nil => true, _ => false, } } fn call(&self, p: Rc, e: Rc, nc: Box>, metac: Cont) -> Cursor { - match self { - OptForm::PrimComb{eval_limit, ins} => { + match &self.inner { + OptFormInner::PrimComb{eval_limit, ins} => { Cursor { f: Self::nil(), c: Cont::PramEval { eval_limit: *eval_limit, to_eval: p, collected: None, e, ins: *ins, nc: nc }, metac } } - OptForm::DeriComb {se, de, params, body, code} => { + OptFormInner::DeriComb {se, de, params, body, code} => { let mut new_e = Rc::clone(se); if let Some(de) = de { new_e = assoc(&de, Rc::clone(&e), new_e); @@ -173,12 +167,9 @@ impl FormT for OptForm { new_e = assoc(¶ms, p, new_e); Cursor { f: Rc::clone(body), c: Cont::Eval { e: new_e, nc: nc }, metac } } - OptForm::ContComb(c) => { + OptFormInner::ContComb(c) => { Cursor { f: p.car().unwrap(), c: Cont::Eval { e, nc: Box::new(c.clone()) }, metac: Cont::CatchRet { nc: nc, restore_meta: Box::new(metac) } } } - OptForm::CodeForm { inner_value, .. } => { - inner_value.call(p, e, nc, metac) - } _ => { panic!("Tried to call not a Prim/DeriComb/ContComb {:?}, nc was {:?}", self, nc); } @@ -191,7 +182,7 @@ impl FormT for OptForm { let de = ps[0].sym().map(|s| s.to_owned()); let params = ps[1].sym().unwrap().to_owned(); let body = Rc::clone(&ps[2]); - Cursor { f: Rc::new(OptForm::DeriComb { se: e, de, params, body, code: Some(Rc::new(RefCell::new(vec![]))) }), c, metac } + Cursor { f: OptForm::new(OptFormInner::DeriComb { se: e, de, params, body, code: Some(Rc::new(RefCell::new(vec![]))) }), c, metac } }, PrimCombI::If => if ps[0].truthy() { Cursor { f: Rc::clone(&ps[1]), c: Cont::Eval { e: e, nc: Box::new(c) }, metac } @@ -203,8 +194,8 @@ impl FormT for OptForm { c: Cont::Eval { e: e, nc: Box::new(Cont::MetaRet) }, metac: Cont::CatchRet { nc: Box::new(c), restore_meta: Box::new(metac) } }, PrimCombI::Shift => Cursor { f: Rc::clone(&ps[0]), - c: Cont::Call { p: Rc::new(OptForm::Pair(Rc::new(OptForm::ContComb(c)), - Rc::new(OptForm::Nil))), + c: Cont::Call { p: OptForm::new(OptFormInner::Pair(OptForm::new(OptFormInner::ContComb(c)), + OptForm::new(OptFormInner::Nil))), e: e, nc: Box::new(Cont::MetaRet) }, metac: Cont::CatchRet { nc: Box::new(metac.clone()), restore_meta: Box::new(metac) } }, @@ -217,78 +208,70 @@ impl FormT for OptForm { Cursor { f: Rc::clone(&ps[1]), c: Cont::Eval { e: e, nc: Box::new(c) }, metac } }, - PrimCombI::Cell => Cursor { f: Rc::new(OptForm::Cell(RefCell::new(Rc::clone(&ps[0])))), c, metac }, - PrimCombI::Set => match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::Cell(cell) => Cursor { f: cell.replace(Rc::clone(&ps[1])), c, metac }, + PrimCombI::Cell => Cursor { f: OptForm::new(OptFormInner::Cell(RefCell::new(Rc::clone(&ps[0])))), c, metac }, + PrimCombI::Set => match &ps[0].inner { + OptFormInner::Cell(cell) => Cursor { f: cell.replace(Rc::clone(&ps[1])), c, metac }, _ => panic!("set on not cell"), }, - PrimCombI::Get => match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::Cell(cell) => Cursor { f: Rc::clone(&cell.borrow()), c, metac }, + PrimCombI::Get => match &ps[0].inner { + OptFormInner::Cell(cell) => Cursor { f: Rc::clone(&cell.borrow()), c, metac }, _ => panic!("get on not cell"), }, - PrimCombI::Cons => Cursor { f: Rc::new(OptForm::Pair(Rc::clone(&ps[0]), Rc::clone(&ps[1]))), c, metac }, + PrimCombI::Cons => Cursor { f: OptForm::new(OptFormInner::Pair(Rc::clone(&ps[0]), Rc::clone(&ps[1]))), c, metac }, PrimCombI::Car => Cursor { f: ps[0].car().unwrap(), c, metac }, PrimCombI::Cdr => Cursor { f: ps[0].cdr().unwrap(), c, metac }, PrimCombI::Quote => Cursor { f: Rc::clone(&ps[0]), c, metac }, - PrimCombI::Eq => Cursor { f: Rc::new(OptForm::Bool(ps[0] == ps[1])), c, metac }, - PrimCombI::Lt => Cursor { f: Rc::new(OptForm::Bool(ps[0].int().unwrap() < ps[1].int().unwrap())), c, metac }, - PrimCombI::LEq => Cursor { f: Rc::new(OptForm::Bool(ps[0].int().unwrap() <= ps[1].int().unwrap())), c, metac }, - PrimCombI::Gt => Cursor { f: Rc::new(OptForm::Bool(ps[0].int().unwrap() > ps[1].int().unwrap())), c, metac }, - PrimCombI::GEq => Cursor { f: Rc::new(OptForm::Bool(ps[0].int().unwrap() >= ps[1].int().unwrap())), c, metac }, + PrimCombI::Eq => Cursor { f: OptForm::new(OptFormInner::Bool(ps[0] == ps[1])), c, metac }, + PrimCombI::Lt => Cursor { f: OptForm::new(OptFormInner::Bool(ps[0].int().unwrap() < ps[1].int().unwrap())), c, metac }, + PrimCombI::LEq => Cursor { f: OptForm::new(OptFormInner::Bool(ps[0].int().unwrap() <= ps[1].int().unwrap())), c, metac }, + PrimCombI::Gt => Cursor { f: OptForm::new(OptFormInner::Bool(ps[0].int().unwrap() > ps[1].int().unwrap())), c, metac }, + PrimCombI::GEq => Cursor { f: OptForm::new(OptFormInner::Bool(ps[0].int().unwrap() >= ps[1].int().unwrap())), c, metac }, - PrimCombI::Plus => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() + ps[1].int().unwrap())), c, metac }, - PrimCombI::Minus => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() - ps[1].int().unwrap())), c, metac }, - PrimCombI::Mult => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() * ps[1].int().unwrap())), c, metac }, - PrimCombI::Div => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() / ps[1].int().unwrap())), c, metac }, - PrimCombI::Mod => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() % ps[1].int().unwrap())), c, metac }, - PrimCombI::And => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() & ps[1].int().unwrap())), c, metac }, - PrimCombI::Or => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() | ps[1].int().unwrap())), c, metac }, - PrimCombI::Xor => Cursor { f: Rc::new(OptForm::Int(ps[0].int().unwrap() ^ ps[1].int().unwrap())), c, metac }, + PrimCombI::Plus => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() + ps[1].int().unwrap())), c, metac }, + PrimCombI::Minus => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() - ps[1].int().unwrap())), c, metac }, + PrimCombI::Mult => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() * ps[1].int().unwrap())), c, metac }, + PrimCombI::Div => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() / ps[1].int().unwrap())), c, metac }, + PrimCombI::Mod => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() % ps[1].int().unwrap())), c, metac }, + PrimCombI::And => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() & ps[1].int().unwrap())), c, metac }, + PrimCombI::Or => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() | ps[1].int().unwrap())), c, metac }, + PrimCombI::Xor => Cursor { f: OptForm::new(OptFormInner::Int(ps[0].int().unwrap() ^ ps[1].int().unwrap())), c, metac }, - PrimCombI::CombP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::PrimComb { .. } => true, - OptForm::DeriComb { .. } => true, + PrimCombI::CombP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner { + OptFormInner::PrimComb { .. } => true, + OptFormInner::DeriComb { .. } => true, _ => false, })), c, metac }, - PrimCombI::CellP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::Cell(_c) => true, + PrimCombI::CellP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner { + OptFormInner::Cell(_c) => true, _ => false, })), c, metac }, - PrimCombI::PairP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::Pair(_a,_b) => true, + PrimCombI::PairP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner { + OptFormInner::Pair(_a,_b) => true, _ => false, })), c, metac }, - PrimCombI::SymbolP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::Symbol(_) => true, - _ => false, + PrimCombI::SymbolP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner { + OptFormInner::Symbol(_) => true, + _ => false, })), c, metac }, - PrimCombI::IntP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::Int(_) => true, - _ => false, + PrimCombI::IntP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner { + OptFormInner::Int(_) => true, + _ => false, })), c, metac }, - PrimCombI::BoolP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { - // TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), - OptForm::Bool(_) => true, + PrimCombI::BoolP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner { + OptFormInner::Bool(_) => true, _ => false, })), c, metac }, - PrimCombI::NilP => Cursor { f: Rc::new(OptForm::Bool(ps[0].is_nil())), c, metac }, + PrimCombI::NilP => Cursor { f: OptForm::new(OptFormInner::Bool(ps[0].is_nil())), c, metac }, } } } fn assoc(k: &str, v: Rc, l: Rc) -> Rc { - Rc::new(OptForm::Pair( - Rc::new(OptForm::Pair( - Rc::new(OptForm::Symbol(k.to_owned())), + OptForm::new(OptFormInner::Pair( + OptForm::new(OptFormInner::Pair( + OptForm::new(OptFormInner::Symbol(k.to_owned())), v)), l)) }