98 lines
2.5 KiB
Rust
98 lines
2.5 KiB
Rust
use hashbrown::{HashMap, HashSet};
|
|
|
|
use derive_more::Constructor;
|
|
use itertools::Itertools;
|
|
|
|
use crate::error::Result;
|
|
use crate::vm::{Env, VM};
|
|
|
|
use super::super::public as p;
|
|
use super::Value;
|
|
|
|
#[repr(C)]
|
|
#[derive(Debug, Constructor, Clone, PartialEq)]
|
|
pub struct AttrSet<'vm> {
|
|
data: HashMap<usize, Value<'vm>>,
|
|
}
|
|
|
|
impl<'vm> AttrSet<'vm> {
|
|
pub fn empty() -> Self {
|
|
AttrSet {
|
|
data: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
pub fn push_attr_force(&mut self, sym: usize, val: Value<'vm>) {
|
|
self.data.insert(sym, val);
|
|
}
|
|
|
|
pub fn push_attr(&mut self, sym: usize, val: Value<'vm>) {
|
|
if self.data.get(&sym).is_some() {
|
|
todo!()
|
|
}
|
|
self.data.insert(sym, val);
|
|
}
|
|
|
|
pub fn select(&self, sym: usize) -> Option<Value<'vm>> {
|
|
self.data.get(&sym).cloned()
|
|
}
|
|
|
|
pub fn has_attr(&self, sym: usize) -> bool {
|
|
self.data.get(&sym).is_some()
|
|
}
|
|
|
|
pub fn capture(&mut self, env: &Env<'vm>) {
|
|
self.data.iter().for_each(|(_, v)| match v.clone() {
|
|
Value::Thunk(ref thunk) => {
|
|
thunk.capture(env.clone());
|
|
}
|
|
_ => (),
|
|
})
|
|
}
|
|
|
|
pub fn update(&mut self, other: &AttrSet<'vm>) {
|
|
for (k, v) in other.data.iter() {
|
|
self.push_attr_force(k.clone(), v.clone())
|
|
}
|
|
}
|
|
|
|
pub fn as_inner(&self) -> &HashMap<usize, Value<'vm>> {
|
|
&self.data
|
|
}
|
|
|
|
pub fn from_inner(data: HashMap<usize, Value<'vm>>) -> Self {
|
|
Self { data }
|
|
}
|
|
|
|
pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<()> {
|
|
let mut map: Vec<_> = self
|
|
.data
|
|
.iter()
|
|
.map(|(k, v)| (k.clone(), v.clone()))
|
|
.collect();
|
|
for (_, v) in map.iter_mut() {
|
|
v.force_deep(vm)?;
|
|
}
|
|
self.data = map.into_iter().collect();
|
|
Ok(())
|
|
}
|
|
|
|
pub fn eq_impl(&self, other: &AttrSet<'vm>, vm: &'vm VM<'_>) -> bool {
|
|
self.data.iter().len() == other.data.iter().len()
|
|
&& std::iter::zip(
|
|
self.data.iter().sorted_by_key(|(k, _)| **k),
|
|
self.data.iter().sorted_by_key(|(k, _)| **k),
|
|
)
|
|
.all(|((_, v1), (_, v2))| v1.eq_impl(v2, vm))
|
|
}
|
|
|
|
pub fn to_public(&self, vm: &'vm VM, seen: &mut HashSet<Value<'vm>>) -> p::Value {
|
|
p::Value::AttrSet(p::AttrSet::new(
|
|
self.data
|
|
.iter()
|
|
.map(|(&sym, value)| (vm.get_sym(sym), value.to_public(vm, seen)))
|
|
.collect(),
|
|
))
|
|
}
|
|
}
|