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;
#[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<OptForm>, de: Option<String>, params: String, body: Rc<OptForm>, code: Option<Rc<RefCell<Vec<ByteCode>>>> },
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)]
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<OptForm> = 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, "<cont>"),
OptForm::CodeForm { code_offset, inner_value, .. } => write!(f, "~code{code_offset}~({inner_value})"),
OptFormInner::ContComb(_) => write!(f, "<cont>"),
}
}
}
impl From<&Form> for Rc<OptForm> {
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<Self> { Rc::new(OptForm { inner, code_ptr: 0 }) }
fn nil() -> Rc<Self> {
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<i32> {
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<OptForm>) -> Option<Rc<OptForm>> {
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<OptForm>,Rc<OptForm>)> {
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<Rc<OptForm>> {
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<Rc<OptForm>> {
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<Self>, e: Rc<Self>, nc: Box<Cont<Self>>, metac: Cont<Self>) -> Cursor<Self> {
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(&params, 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<OptForm>, l: Rc<OptForm>) -> Rc<OptForm> {
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))
}