miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

swap to single struct wrapper scaffolding

Browse Source
This commit is contained in:
Nathan Braswell
2023-07-13 22:52:49 -04:00
parent 6edbe7d2c8
commit 15cab8799d
1 changed files with 102 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

221
kv/src/opt.rs
View File

@@ -8,7 +8,13 @@ use crate::eval::{FormT,Cont,Cursor,PrimCombI};
use crate::basic::Form; use crate::basic::Form;
#[derive(Debug, Eq, PartialEq)] #[derive(Debug, Eq, PartialEq)]
pub enum OptForm { pub struct OptForm {
inner: OptFormInner,
code_ptr: usize
}
#[derive(Debug, Eq, PartialEq)]
pub enum OptFormInner {
Nil, Nil,
Int(i32), Int(i32),
Bool(bool), Bool(bool),
@@ -18,10 +24,6 @@ pub enum OptForm {
PrimComb { eval_limit: i32, ins: PrimCombI }, PrimComb { eval_limit: i32, ins: PrimCombI },
DeriComb { se: Rc<OptForm>, de: Option<String>, params: String, body: Rc<OptForm>, code: Option<Rc<RefCell<Vec<ByteCode>>>> }, DeriComb { se: Rc<OptForm>, de: Option<String>, params: String, body: Rc<OptForm>, code: Option<Rc<RefCell<Vec<ByteCode>>>> },
ContComb(Cont<OptForm>), ContComb(Cont<OptForm>),
// 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<RefCell<Vec<ByteCode>>>, inner_value: Rc<OptForm> },
} }
#[derive(Debug, Eq, PartialEq)] #[derive(Debug, Eq, PartialEq)]
pub enum ByteCode { pub enum ByteCode {
@@ -30,94 +32,91 @@ pub enum ByteCode {
impl fmt::Display for OptForm { impl fmt::Display for OptForm {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match &self.inner {
OptForm::Nil => write!(f, "nil"), OptFormInner::Nil => write!(f, "nil"),
OptForm::Int(i) => write!(f, "{i}"), OptFormInner::Int(i) => write!(f, "{i}"),
OptForm::Bool(b) => write!(f, "{b}"), OptFormInner::Bool(b) => write!(f, "{b}"),
OptForm::Symbol(s) => write!(f, "{s}"), OptFormInner::Symbol(s) => write!(f, "{s}"),
OptForm::Cell(c) => write!(f, "@{}", c.borrow()), OptFormInner::Cell(c) => write!(f, "@{}", c.borrow()),
OptForm::Pair(car, cdr) => { OptFormInner::Pair(car, cdr) => {
write!(f, "({}", car)?; write!(f, "({}", car)?;
let mut traverse: Rc<OptForm> = Rc::clone(cdr); let mut traverse: Rc<OptForm> = Rc::clone(cdr);
loop { loop {
match &*traverse { match &traverse.inner {
OptForm::Pair(ref carp, ref cdrp) => { OptFormInner::Pair(ref carp, ref cdrp) => {
write!(f, " {}", carp)?; write!(f, " {}", carp)?;
traverse = Rc::clone(cdrp); traverse = Rc::clone(cdrp);
}, },
OptForm::Nil => { OptFormInner::Nil => {
write!(f, ")")?; write!(f, ")")?;
return Ok(()); return Ok(());
}, },
x => { x => {
write!(f, ". {x})")?; write!(f, ". {})", traverse)?;
return Ok(()); return Ok(());
}, },
} }
} }
}, },
OptForm::PrimComb { eval_limit, ins } => write!(f, "<{eval_limit}> - {ins:?}"), OptFormInner::PrimComb { eval_limit, ins } => write!(f, "<{eval_limit}> - {ins:?}"),
OptForm::DeriComb { se: _, de, params, body, code: _ } => { OptFormInner::DeriComb { se: _, de, params, body, code: _ } => {
write!(f, "<{} {} {}>", de.as_ref().unwrap_or(&"".to_string()), params, body) write!(f, "<{} {} {}>", de.as_ref().unwrap_or(&"".to_string()), params, body)
}, },
OptForm::ContComb(_) => write!(f, "<cont>"), OptFormInner::ContComb(_) => write!(f, "<cont>"),
OptForm::CodeForm { code_offset, inner_value, .. } => write!(f, "~code{code_offset}~({inner_value})"),
} }
} }
} }
impl From<&Form> for Rc<OptForm> { impl From<&Form> for Rc<OptForm> {
fn from(x: &Form) -> Self { fn from(x: &Form) -> Self {
Rc::new(match x { match x {
Form::Nil => OptForm::Nil, Form::Nil => OptForm::new(OptFormInner::Nil),
Form::Int(i) => OptForm::Int(*i), Form::Int(i) => OptForm::new(OptFormInner::Int(*i)),
Form::Bool(b) => OptForm::Bool(*b), Form::Bool(b) => OptForm::new(OptFormInner::Bool(*b)),
Form::Symbol(s) => OptForm::Symbol(s.to_owned()), Form::Symbol(s) => OptForm::new(OptFormInner::Symbol(s.to_owned())),
Form::Cell(cell) => panic!("bad"), Form::Cell(cell) => panic!("bad"),
Form::Pair(car,cdr) => OptForm::Pair((&**car).into(), (&**cdr).into()), Form::Pair(car,cdr) => OptForm::new(OptFormInner::Pair((&**car).into(), (&**cdr).into())),
Form::PrimComb { eval_limit, ins } => OptForm::PrimComb { eval_limit: *eval_limit, ins: *ins }, Form::PrimComb { eval_limit, ins } => OptForm::new(OptFormInner::PrimComb { eval_limit: *eval_limit, ins: *ins }),
Form::DeriComb { .. } => panic!("bad"), Form::DeriComb { .. } => panic!("bad"),
Form::ContComb(c) => panic!("bad"), Form::ContComb(c) => panic!("bad"),
}) }
} }
} }
impl OptForm { impl OptForm {
fn new(inner: OptFormInner) -> Rc<Self> { Rc::new(OptForm { inner, code_ptr: 0 }) }
fn nil() -> Rc<Self> { fn nil() -> Rc<Self> {
Rc::new(OptForm::Nil) OptForm::new(OptFormInner::Nil)
} }
fn truthy(&self) -> bool { fn truthy(&self) -> bool {
match self { match &self.inner {
OptForm::Bool(b) => *b, OptFormInner::Bool(b) => *b,
OptForm::Nil => false, OptFormInner::Nil => false,
OptForm::CodeForm { inner_value, .. } => inner_value.truthy(), _ => true,
_ => true,
} }
} }
fn int(&self) -> Option<i32> { fn int(&self) -> Option<i32> {
match self { match &self.inner {
OptForm::Int(i) => Some(*i), OptFormInner::Int(i) => Some(*i),
OptForm::CodeForm { inner_value, .. } => inner_value.int(), _ => None,
_ => None,
} }
} }
fn append(&self, x: Rc<OptForm>) -> Option<Rc<OptForm>> { fn append(&self, x: Rc<OptForm>) -> Option<Rc<OptForm>> {
match self { match &self.inner {
OptForm::Pair(car, cdr) => cdr.append(x).map(|x| Rc::new(OptForm::Pair(Rc::clone(car), x))), OptFormInner::Pair(car, cdr) => cdr.append(x).map(|x| OptForm::new(OptFormInner::Pair(Rc::clone(car), x))),
OptForm::Nil => Some(Rc::new(OptForm::Pair(x, Rc::new(OptForm::Nil)))), OptFormInner::Nil => Some(OptForm::new(OptFormInner::Pair(x, OptForm::new(OptFormInner::Nil )))),
OptForm::CodeForm { inner_value, .. } => inner_value.append(x),
_ => None, _ => None,
} }
} }
pub fn congruent(&self, other: &Form) -> bool { pub fn congruent(&self, other: &Form) -> bool {
match other { match other {
Form::Nil => *self == OptForm::Nil, Form::Nil => self.inner == OptFormInner::Nil,
Form::Int(i) => *self == OptForm::Int(*i), Form::Int(i) => self.inner == OptFormInner::Int(*i),
Form::Bool(b) => *self == OptForm::Bool(*b), Form::Bool(b) => self.inner == OptFormInner::Bool(*b),
Form::Symbol(s) => *self == OptForm::Symbol(s.to_owned()), Form::Symbol(s) => self.inner == OptFormInner::Symbol(s.to_owned()),
Form::Cell(cell) => panic!("bad"), Form::Cell(cell) => panic!("bad"),
Form::Pair(car,cdr) => match self { OptForm::Pair(carp, cdrp) => carp.congruent(car) && cdrp.congruent(cdr), _ => false }, Form::Pair(car,cdr) => match &self.inner { OptFormInner::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::PrimComb { eval_limit, ins } => self.inner == OptFormInner::PrimComb { eval_limit: *eval_limit, ins: *ins },
Form::DeriComb { .. } => panic!("bad"), Form::DeriComb { .. } => panic!("bad"),
Form::ContComb(c) => panic!("bad"), Form::ContComb(c) => panic!("bad"),
} }
@@ -126,46 +125,41 @@ impl OptForm {
impl FormT for OptForm { impl FormT for OptForm {
fn sym(&self) -> Option<&str> { fn sym(&self) -> Option<&str> {
match self { match &self.inner {
OptForm::Symbol(s) => Some(s), OptFormInner::Symbol(s) => Some(s),
OptForm::CodeForm { inner_value, .. } => inner_value.sym(),
_ => None, _ => None,
} }
} }
fn pair(&self) -> Option<(Rc<OptForm>,Rc<OptForm>)> { fn pair(&self) -> Option<(Rc<OptForm>,Rc<OptForm>)> {
match self { match &self.inner {
OptForm::Pair(car, cdr) => Some((Rc::clone(car),Rc::clone(cdr))), OptFormInner::Pair(car, cdr) => Some((Rc::clone(car),Rc::clone(cdr))),
OptForm::CodeForm { inner_value, .. } => inner_value.pair(),
_ => None, _ => None,
} }
} }
fn car(&self) -> Option<Rc<OptForm>> { fn car(&self) -> Option<Rc<OptForm>> {
match self { match &self.inner {
OptForm::Pair(car, _cdr) => Some(Rc::clone(car)), OptFormInner::Pair(car, _cdr) => Some(Rc::clone(car)),
OptForm::CodeForm { inner_value, .. } => inner_value.car(),
_ => None, _ => None,
} }
} }
fn cdr(&self) -> Option<Rc<OptForm>> { fn cdr(&self) -> Option<Rc<OptForm>> {
match self { match &self.inner {
OptForm::Pair(_car, cdr) => Some(Rc::clone(cdr)), OptFormInner::Pair(_car, cdr) => Some(Rc::clone(cdr)),
OptForm::CodeForm { inner_value, .. } => inner_value.cdr(),
_ => None, _ => None,
} }
} }
fn is_nil(&self) -> bool { fn is_nil(&self) -> bool {
match self { match &self.inner {
OptForm::Nil => true, OptFormInner::Nil => true,
OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(),
_ => false, _ => false,
} }
} }
fn call(&self, p: Rc<Self>, e: Rc<Self>, nc: Box<Cont<Self>>, metac: Cont<Self>) -> Cursor<Self> { fn call(&self, p: Rc<Self>, e: Rc<Self>, nc: Box<Cont<Self>>, metac: Cont<Self>) -> Cursor<Self> {
match self { match &self.inner {
OptForm::PrimComb{eval_limit, ins} => { 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 } 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); let mut new_e = Rc::clone(se);
if let Some(de) = de { if let Some(de) = de {
new_e = assoc(&de, Rc::clone(&e), new_e); new_e = assoc(&de, Rc::clone(&e), new_e);
@@ -173,12 +167,9 @@ impl FormT for OptForm {
new_e = assoc(&params, p, new_e); new_e = assoc(&params, p, new_e);
Cursor { f: Rc::clone(body), c: Cont::Eval { e: new_e, nc: nc }, metac } 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) } } 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); 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 de = ps[0].sym().map(|s| s.to_owned());
let params = ps[1].sym().unwrap().to_owned(); let params = ps[1].sym().unwrap().to_owned();
let body = Rc::clone(&ps[2]); 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() { PrimCombI::If => if ps[0].truthy() {
Cursor { f: Rc::clone(&ps[1]), c: Cont::Eval { e: e, nc: Box::new(c) }, metac } 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) }, c: Cont::Eval { e: e, nc: Box::new(Cont::MetaRet) },
metac: Cont::CatchRet { nc: Box::new(c), restore_meta: Box::new(metac) } }, metac: Cont::CatchRet { nc: Box::new(c), restore_meta: Box::new(metac) } },
PrimCombI::Shift => Cursor { f: Rc::clone(&ps[0]), PrimCombI::Shift => Cursor { f: Rc::clone(&ps[0]),
c: Cont::Call { p: Rc::new(OptForm::Pair(Rc::new(OptForm::ContComb(c)), c: Cont::Call { p: OptForm::new(OptFormInner::Pair(OptForm::new(OptFormInner::ContComb(c)),
Rc::new(OptForm::Nil))), OptForm::new(OptFormInner::Nil))),
e: e, e: e,
nc: Box::new(Cont::MetaRet) }, nc: Box::new(Cont::MetaRet) },
metac: Cont::CatchRet { nc: Box::new(metac.clone()), restore_meta: Box::new(metac) } }, 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 } 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::Cell => Cursor { f: OptForm::new(OptFormInner::Cell(RefCell::new(Rc::clone(&ps[0])))), c, metac },
PrimCombI::Set => match &*ps[0] { PrimCombI::Set => match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::Cell(cell) => Cursor { f: cell.replace(Rc::clone(&ps[1])), c, metac },
OptForm::Cell(cell) => Cursor { f: cell.replace(Rc::clone(&ps[1])), c, metac },
_ => panic!("set on not cell"), _ => panic!("set on not cell"),
}, },
PrimCombI::Get => match &*ps[0] { PrimCombI::Get => match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::Cell(cell) => Cursor { f: Rc::clone(&cell.borrow()), c, metac },
OptForm::Cell(cell) => Cursor { f: Rc::clone(&cell.borrow()), c, metac },
_ => panic!("get on not cell"), _ => 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::Car => Cursor { f: ps[0].car().unwrap(), c, metac },
PrimCombI::Cdr => Cursor { f: ps[0].cdr().unwrap(), c, metac }, PrimCombI::Cdr => Cursor { f: ps[0].cdr().unwrap(), c, metac },
PrimCombI::Quote => Cursor { f: Rc::clone(&ps[0]), 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::Eq => Cursor { f: OptForm::new(OptFormInner::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::Lt => Cursor { f: OptForm::new(OptFormInner::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::LEq => Cursor { f: OptForm::new(OptFormInner::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::Gt => Cursor { f: OptForm::new(OptFormInner::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::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::Plus => Cursor { f: OptForm::new(OptFormInner::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::Minus => Cursor { f: OptForm::new(OptFormInner::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::Mult => Cursor { f: OptForm::new(OptFormInner::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::Div => Cursor { f: OptForm::new(OptFormInner::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::Mod => Cursor { f: OptForm::new(OptFormInner::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::And => Cursor { f: OptForm::new(OptFormInner::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::Or => Cursor { f: OptForm::new(OptFormInner::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::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] { PrimCombI::CombP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::PrimComb { .. } => true,
OptForm::PrimComb { .. } => true, OptFormInner::DeriComb { .. } => true,
OptForm::DeriComb { .. } => true,
_ => false, _ => false,
})), c, metac }, })), c, metac },
PrimCombI::CellP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { PrimCombI::CellP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::Cell(_c) => true,
OptForm::Cell(_c) => true,
_ => false, _ => false,
})), c, metac }, })), c, metac },
PrimCombI::PairP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { PrimCombI::PairP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::Pair(_a,_b) => true,
OptForm::Pair(_a,_b) => true,
_ => false, _ => false,
})), c, metac }, })), c, metac },
PrimCombI::SymbolP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { PrimCombI::SymbolP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::Symbol(_) => true,
OptForm::Symbol(_) => true, _ => false,
_ => false,
})), c, metac }, })), c, metac },
PrimCombI::IntP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { PrimCombI::IntP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::Int(_) => true,
OptForm::Int(_) => true, _ => false,
_ => false,
})), c, metac }, })), c, metac },
PrimCombI::BoolP => Cursor { f: Rc::new(OptForm::Bool(match &*ps[0] { PrimCombI::BoolP => Cursor { f: OptForm::new(OptFormInner::Bool(match &ps[0].inner {
// TODO OptForm::CodeForm { inner_value, .. } => inner_value.is_nil(), OptFormInner::Bool(_) => true,
OptForm::Bool(_) => true,
_ => false, _ => false,
})), c, metac }, })), 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<OptForm>, l: Rc<OptForm>) -> Rc<OptForm> { fn assoc(k: &str, v: Rc<OptForm>, l: Rc<OptForm>) -> Rc<OptForm> {
Rc::new(OptForm::Pair( OptForm::new(OptFormInner::Pair(
Rc::new(OptForm::Pair( OptForm::new(OptFormInner::Pair(
Rc::new(OptForm::Symbol(k.to_owned())), OptForm::new(OptFormInner::Symbol(k.to_owned())),
v)), v)),
l)) l))
} }