imxyy1soope1/nixjit
1
0
Fork 0
Code Issues Pull Requests Actions Projects 1 Releases Activity

feat: better builtins implementaion

Browse Source 
get rid of circular references
This commit is contained in:
imxyy_soope_
2025-05-17 18:31:36 +08:00
parent 8480e0891b
commit ff9afd0cc1
19 changed files with 191 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/ty/common.rs
View File

@@ -2,7 +2,6 @@ use std::fmt::{Display, Formatter, Result as FmtResult};
use derive_more::Constructor;
#[derive(Clone, Debug, PartialEq, Constructor, Hash)]
pub struct Catchable {
msg: String,
@@ -13,4 +12,3 @@ impl Display for Catchable {
write!(f, "<error: {}>", self.msg)
}
}

130
src/ty/internal/attrset.rs
View File

@@ -1,11 +1,13 @@
use std::rc::Rc;
use std::collections::HashSet;
use std::rc::Rc;
use derive_more::Constructor;
use itertools::Itertools;
use rpds::HashTrieMap;
use crate::error::Result;
use crate::vm::{Env, VM};
use super::super::public as p;
use super::Value;
@@ -27,7 +29,7 @@ impl<'vm> AttrSet<'vm> {
}
pub fn push_attr(&mut self, sym: usize, val: Value<'vm>) {
if self.data.get_mut(&sym).is_some() {
if self.data.get(&sym).is_some() {
todo!()
}
self.data.insert_mut(sym, val);
@@ -42,17 +44,12 @@ impl<'vm> AttrSet<'vm> {
}
pub fn capture(&mut self, env: &Rc<Env<'vm>>) {
self
.data
.iter()
.for_each(|(_, v)| {
match v.clone() {
Value::Thunk(ref thunk) => {
thunk.capture(env.clone());
}
_ => ()
}
})
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>) {
@@ -61,20 +58,18 @@ impl<'vm> AttrSet<'vm> {
}
}
pub fn update_rec(&mut self, other: &RecAttrSet<'vm>) {
for (k, v) in other.data.map.borrow().iter() {
self.push_attr_force(k.clone(), v.clone())
}
}
pub fn as_inner(&self) -> &HashTrieMap<usize, Value<'vm>> {
&self.data
}
pub fn from_inner(data: HashTrieMap<usize, Value<'vm>>) -> Self {
Self { data }
}
pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<()> {
let mut map: Vec<_> = self
.data
.into_iter()
.iter()
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
for (_, v) in map.iter_mut() {
@@ -84,99 +79,20 @@ impl<'vm> AttrSet<'vm> {
Ok(())
}
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.clone().to_public(vm, seen)))
.collect(),
))
}
}
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct RecAttrSet<'vm> {
data: Rc<Env<'vm>>,
}
impl<'vm> RecAttrSet<'vm> {
pub fn empty() -> Self {
RecAttrSet {
data: Rc::default(),
}
}
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.lookup(sym).is_some() {
todo!()
}
self.data.insert(sym, val);
}
pub fn select(&self, sym: usize) -> Option<Value<'vm>> {
self.data.lookup(sym)
}
pub fn has_attr(&self, sym: usize) -> bool {
self.data.lookup(sym).is_some()
}
pub fn update(&mut self, other: RecAttrSet<'vm>) {
for (k, v) in other.data.map.borrow().iter() {
self.push_attr_force(k.clone(), v.clone())
}
}
pub fn update_normal(&self, other: &AttrSet<'vm>) -> AttrSet<'vm> {
let map = self
.data
.map
.borrow()
.into_iter()
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
let mut new = AttrSet::new(map);
for (k, v) in other.data.iter() {
new.push_attr_force(k.clone(), v.clone())
}
new
}
pub fn into_inner(self) -> Rc<Env<'vm>> {
self.data
}
pub fn from_inner(data: Rc<Env<'vm>>) -> Self {
RecAttrSet { data }
}
pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<()> {
let mut map: Vec<_> = self
.data
.map
.borrow()
.into_iter()
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
map.iter_mut()
.map(|(_, v)| v.force_deep(vm).map(|_| ()))
.find(|v| v.is_err())
.map_or(Ok(()), |err| err)?;
*self.data.map.borrow_mut() = 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
.map
.borrow()
.iter()
.map(|(&sym, value)| (vm.get_sym(sym), value.clone().to_public(vm, seen)))
.map(|(&sym, value)| (vm.get_sym(sym), value.to_public(vm, seen)))
.collect(),
))
}

4
src/ty/internal/cnst.rs
View File

@@ -9,7 +9,7 @@ pub enum Const {
Int(i64),
Float(f64),
String(EcoString),
Null
Null,
}
impl Hash for Const {
@@ -68,6 +68,8 @@ impl PartialEq for Const {
(Bool(a), Bool(b)) => a == b,
(Int(a), Int(b)) => a == b,
(Float(a), Float(b)) => a == b,
(Int(a), Float(b)) => *a as f64 == *b,
(Float(a), Int(b)) => *b as f64 == *a,
(String(a), String(b)) => a == b,
_ => false,
}

23
src/ty/internal/func.rs
View File

@@ -1,8 +1,8 @@
use std::collections::HashMap;
use std::rc::Rc;
use itertools::Itertools;
use rpds::HashTrieMap;
use derive_more::Constructor;
use itertools::Itertools;
use crate::bytecode::Func as BFunc;
use crate::error::Result;
@@ -40,13 +40,14 @@ impl From<ir::Param> for Param {
}
}
pub type JITFunc<'vm> = unsafe extern "C" fn(vm: *mut VM<'_>, *mut Env<'vm>, *mut Value<'vm>) -> Value<'vm>;
pub type JITFunc<'vm> =
unsafe extern "C" fn(vm: *mut VM<'_>, *mut Env<'vm>, *mut Value<'vm>) -> Value<'vm>;
#[derive(Debug, Clone, Constructor)]
pub struct Func<'vm> {
pub func: &'vm BFunc,
pub env: Rc<Env<'vm>>,
pub compiled: Option<JITFunc<'vm>>
pub compiled: Option<JITFunc<'vm>>,
}
impl<'vm> Func<'vm> {
@@ -56,14 +57,14 @@ impl<'vm> Func<'vm> {
let env = Rc::new(self.env.as_ref().clone());
match self.func.param.clone() {
Ident(ident) => env.enter(HashTrieMap::new().insert(ident.into(), arg)),
Ident(ident) => env.enter([(ident.into(), arg)].into_iter()),
Formals {
formals,
ellipsis,
alias,
} => {
let arg = arg.unwrap_attr_set();
let mut new = HashTrieMap::new();
let mut new = Vec::with_capacity(formals.len() + alias.iter().len());
if !ellipsis
&& arg
.as_inner()
@@ -78,14 +79,16 @@ impl<'vm> Func<'vm> {
let formal = formal.clone().into();
let arg = arg
.select(formal)
.or_else(|| default.map(|idx| Value::Thunk(Thunk::new(vm.get_thunk(idx)).into())))
.or_else(|| {
default.map(|idx| Value::Thunk(Thunk::new(vm.get_thunk(idx)).into()))
})
.unwrap();
new.insert_mut(formal, arg);
new.push((formal, arg));
}
if let Some(alias) = alias {
new.insert_mut(alias.clone().into(), Value::AttrSet(arg));
new.push((alias.clone().into(), Value::AttrSet(arg)));
}
env.enter(new);
env.enter(new.into_iter());
}
}

80
src/ty/internal/mod.rs
View File

@@ -32,28 +32,43 @@ pub enum Value<'vm> {
Thunk(Rc<Thunk<'vm>>),
ThunkRef(&'vm Thunk<'vm>),
AttrSet(Rc<AttrSet<'vm>>),
RecAttrSet(Rc<RecAttrSet<'vm>>),
List(Rc<List<'vm>>),
Catchable(c::Catchable),
PrimOp(Rc<PrimOp<'vm>>),
PartialPrimOp(Rc<PartialPrimOp<'vm>>),
Func(Rc<Func<'vm>>),
Builtins,
}
impl Hash for Value<'_> {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
use Value::*;
std::mem::discriminant(self).hash(state);
match self {
Const(x) => x.hash(state),
Thunk(x) => (x.as_ref() as *const self::Thunk).hash(state),
ThunkRef(x) => (*x as *const self::Thunk).hash(state),
AttrSet(x) => (x.as_ref() as *const self::AttrSet).hash(state),
RecAttrSet(x) => (x.as_ref() as *const self::RecAttrSet).hash(state),
List(x) => (x.as_ref() as *const self::List).hash(state),
Catchable(x) => x.hash(state),
PrimOp(x) => (x.as_ref() as *const self::PrimOp).hash(state),
PartialPrimOp(x) => (x.as_ref() as *const self::PartialPrimOp).hash(state),
Func(x) => (x.as_ref() as *const self::Func).hash(state),
Builtins => (),
}
}
}
impl<'vm> Value<'vm> {
fn eq_impl(&self, other: &Self, vm: &'vm VM<'_>) -> bool {
use Value::*;
match (self, other) {
(Const(a), Const(b)) => a.eq(b),
(AttrSet(a), AttrSet(b)) => a.eq_impl(b, vm),
(List(a), List(b)) => a.eq(b),
(Builtins, AttrSet(attrs)) => attrs.has_attr(vm.new_sym("builtins")),
(AttrSet(attrs), Builtins) => attrs.has_attr(vm.new_sym("builtins")),
_ => false,
}
}
}
@@ -65,7 +80,6 @@ pub enum ValueAsRef<'v, 'vm: 'v> {
Const(&'v Const),
Thunk(&'v Thunk<'vm>),
AttrSet(&'v AttrSet<'vm>),
RecAttrSet(&'v RecAttrSet<'vm>),
List(&'v List<'vm>),
Catchable(&'v c::Catchable),
PrimOp(&'v PrimOp<'vm>),
@@ -78,7 +92,6 @@ pub enum ValueAsMut<'v, 'vm: 'v> {
Const(&'v mut Const),
Thunk(&'v Thunk<'vm>),
AttrSet(&'v mut AttrSet<'vm>),
RecAttrSet(&'v mut RecAttrSet<'vm>),
List(&'v mut List<'vm>),
Catchable(&'v mut c::Catchable),
PrimOp(&'v mut PrimOp<'vm>),
@@ -95,12 +108,12 @@ impl<'v, 'vm: 'v> Value<'vm> {
Thunk(x) => R::Thunk(x),
ThunkRef(x) => R::Thunk(x),
AttrSet(x) => R::AttrSet(x),
RecAttrSet(x) => R::RecAttrSet(x),
List(x) => R::List(x),
Catchable(x) => R::Catchable(x),
PrimOp(x) => R::PrimOp(x),
PartialPrimOp(x) => R::PartialPrimOp(x),
Func(x) => R::Func(x),
Builtins => unreachable!(),
}
}
@@ -112,12 +125,12 @@ impl<'v, 'vm: 'v> Value<'vm> {
Thunk(x) => M::Thunk(x),
ThunkRef(x) => M::Thunk(x),
AttrSet(x) => M::AttrSet(Rc::make_mut(x)),
RecAttrSet(x) => M::RecAttrSet(Rc::make_mut(x)),
List(x) => M::List(Rc::make_mut(x)),
Catchable(x) => M::Catchable(x),
PrimOp(x) => M::PrimOp(Rc::make_mut(x)),
PartialPrimOp(x) => M::PartialPrimOp(Rc::make_mut(x)),
Func(x) => M::Func(x),
Builtins => unreachable!(),
}
}
}
@@ -135,19 +148,19 @@ impl<'vm> Value<'vm> {
Thunk(_) => "thunk",
ThunkRef(_) => "thunk",
AttrSet(_) => "set",
RecAttrSet(_) => "set",
List(_) => "list",
Catchable(_) => unreachable!(),
PrimOp(_) => "lambda",
PartialPrimOp(_) => "lambda",
Func(_) => "lambda",
Builtins => "set",
}
}
pub fn callable(&self) -> bool {
match self {
Value::PrimOp(_) | Value::PartialPrimOp(_) | Value::Func(_) => true,
Value::AttrSet(_) | Value::RecAttrSet(_) => todo!(),
Value::AttrSet(_) => todo!(),
_ => false,
}
}
@@ -318,8 +331,6 @@ impl<'vm> Value<'vm> {
pub fn push_attr(&mut self, sym: usize, val: Self) -> &mut Self {
if let Value::AttrSet(attrs) = self {
Rc::make_mut(attrs).push_attr(sym, val)
} else if let Value::RecAttrSet(attrs) = self {
Rc::make_mut(attrs).push_attr(sym, val)
} else if let Value::Catchable(_) = self {
} else if let Value::Catchable(_) = val {
*self = val
@@ -335,13 +346,6 @@ impl<'vm> Value<'vm> {
Rc::make_mut(&mut a).update(b.as_ref());
Value::AttrSet(a)
}
(Value::RecAttrSet(a), Value::AttrSet(b)) => {
Value::AttrSet(a.update_normal(b.as_ref()).into())
}
(Value::AttrSet(mut a), Value::RecAttrSet(b)) => {
Rc::make_mut(&mut a).update_rec(b.as_ref());
Value::AttrSet(a)
}
(x @ Value::Catchable(_), _) | (_, x @ Value::Catchable(_)) => x,
_ => todo!(),
}
@@ -352,23 +356,22 @@ impl<'vm> Value<'vm> {
Value::AttrSet(attrs) => attrs
.select(sym)
.ok_or_else(|| Error::EvalError(format!("{} not found", vm.get_sym(sym)))),
Value::RecAttrSet(attrs) => attrs
.select(sym)
.ok_or_else(|| Error::EvalError(format!("{} not found", vm.get_sym(sym)))),
Value::Catchable(_) => return Ok(self),
_ => Err(Error::EvalError(format!(
"cannot select from {:?}",
self.typename()
))),
}?;
*self = val;
if let Value::Builtins = val {
} else {
*self = val;
}
Ok(self)
}
pub fn select_with_default(&mut self, sym: usize, default: Self) -> Result<&mut Self> {
let val = match self {
Value::AttrSet(attrs) => attrs.select(sym).unwrap_or(default),
Value::RecAttrSet(attrs) => attrs.select(sym).unwrap_or(default),
Value::Catchable(_) => return Ok(self),
_ => {
return Err(Error::EvalError(format!(
@@ -377,7 +380,10 @@ impl<'vm> Value<'vm> {
)));
}
};
*self = val;
if let Value::Builtins = val {
} else {
*self = val;
}
Ok(self)
}
@@ -385,9 +391,6 @@ impl<'vm> Value<'vm> {
if let Value::AttrSet(attrs) = self {
let val = VmConst(Const::Bool(attrs.has_attr(sym)));
*self = val;
} else if let Value::RecAttrSet(attrs) = self {
let val = VmConst(Const::Bool(attrs.has_attr(sym)));
*self = val;
} else if let Value::Catchable(_) = self {
} else {
*self = VmConst(Const::Bool(false));
@@ -429,28 +432,29 @@ impl<'vm> Value<'vm> {
}
Value::List(list) => Rc::make_mut(list).force_deep(vm)?,
Value::AttrSet(attrs) => Rc::make_mut(attrs).force_deep(vm)?,
Value::RecAttrSet(attrs) => Rc::make_mut(attrs).force_deep(vm)?,
_ => (),
}
Ok(self)
}
pub fn to_public(&self, vm: &'vm VM, seen: &mut HashSet<Value<'vm>>) -> p::Value {
use self::Value::*;
use p::Value;
if seen.contains(self) {
return p::Value::Repeated;
return Value::Repeated;
}
seen.insert(self.clone());
match self {
Value::AttrSet(attrs) => attrs.to_public(vm, seen),
Value::RecAttrSet(attrs) => attrs.to_public(vm, seen),
Value::List(list) => list.to_public(vm, seen),
Value::Catchable(catchable) => p::Value::Catchable(catchable.clone()),
Value::Const(cnst) => p::Value::Const(cnst.clone().into()),
Value::Thunk(_) => p::Value::Thunk,
Value::ThunkRef(_) => p::Value::Thunk,
Value::PrimOp(primop) => p::Value::PrimOp(primop.name),
Value::PartialPrimOp(primop) => p::Value::PartialPrimOp(primop.name),
Value::Func(_) => p::Value::Func,
AttrSet(attrs) => attrs.to_public(vm, seen),
List(list) => list.to_public(vm, seen),
Catchable(catchable) => Value::Catchable(catchable.clone()),
Const(cnst) => Value::Const(cnst.clone().into()),
Thunk(_) => Value::Thunk,
ThunkRef(_) => Value::Thunk,
PrimOp(primop) => Value::PrimOp(primop.name),
PartialPrimOp(primop) => Value::PartialPrimOp(primop.name),
Func(_) => Value::Func,
Builtins => Value::Repeated,
}
}
}

18
src/ty/internal/primop.rs
View File

@@ -2,8 +2,8 @@ use std::rc::Rc;
use derive_more::Constructor;
use crate::vm::VM;
use crate::error::Result;
use crate::vm::VM;
use super::Value;
@@ -23,12 +23,16 @@ impl PartialEq for PrimOp<'_> {
impl<'vm> PrimOp<'vm> {
pub fn call(&self, vm: &'vm VM<'_>, args: Vec<Value<'vm>>) -> Result<Value<'vm>> {
if (args.len()) < self.arity {
Value::PartialPrimOp(PartialPrimOp {
name: self.name,
arity: self.arity - args.len(),
args,
func: self.func,
}.into()).ok()
Value::PartialPrimOp(
PartialPrimOp {
name: self.name,
arity: self.arity - args.len(),
args,
func: self.func,
}
.into(),
)
.ok()
} else if args.len() == self.arity {
(self.func)(vm, args)
} else {

6
src/ty/public/cnst.rs
View File

@@ -13,7 +13,7 @@ pub enum Const {
Int(i64),
Float(f64),
String(EcoString),
Null
Null,
}
impl Display for Const {
@@ -24,7 +24,7 @@ impl Display for Const {
Int(i) => write!(f, "{i}"),
Float(float) => write!(f, "{float}"),
String(s) => write!(f, "{s}"),
Null => write!(f, "null")
Null => write!(f, "null"),
}
}
}
@@ -37,7 +37,7 @@ impl From<i::Const> for Const {
Int(int) => Const::Int(int),
Float(float) => Const::Float(float),
String(string) => Const::String(string),
Null => Const::Null
Null => Const::Null,
}
}
}

6
src/ty/public/mod.rs
View File

@@ -3,9 +3,9 @@ use std::ops::Deref;
use std::sync::LazyLock;
use derive_more::{Constructor, IsVariant, Unwrap};
use rpds::{HashTrieMap, VectorSync};
use ecow::EcoString;
use regex::Regex;
use rpds::{HashTrieMap, VectorSync};
use super::common::*;
@@ -112,7 +112,7 @@ pub enum Value {
Func,
PrimOp(&'static str),
PartialPrimOp(&'static str),
Repeated
Repeated,
}
impl Display for Value {
@@ -127,7 +127,7 @@ impl Display for Value {
Func => write!(f, "<LAMBDA>"),
PrimOp(x) => write!(f, "<PRIMOP {x}>"),
PartialPrimOp(x) => write!(f, "<PARTIAL PRIMOP {x}>"),
Repeated => write!(f, "<REPEATED>")
Repeated => write!(f, "<REPEATED>"),
}
}
}