use std::fmt;
use std::sync::{Arc, Mutex, OnceLock, PoisonError};
use dive_ir::ExprId;
use dive_value::{Ctx, DeferredKind, DeferredSet, Result as VResult, Value, ValueError, tlc};
use crate::core::Core;
use crate::env::{Env, Ev, St, Sv};
use crate::error::EvalError;
#[derive(Clone, Debug)]
pub(crate) struct BoundVal {
pub(crate) slots: Vec<usize>,
pub(crate) tuple: bool,
pub(crate) domain: Value,
}
#[derive(Clone, Debug)]
pub(crate) struct Except {
pub(crate) path: Arc<[Value]>,
pub(crate) idx: usize,
pub(crate) value: Ev,
}
impl Except {
pub(crate) fn current(&self) -> &Value {
&self.path[self.idx]
}
pub(crate) fn is_last(&self) -> bool {
self.idx + 1 == self.path.len()
}
pub(crate) fn advanced(&self) -> Self {
Self {
path: self.path.clone(),
idx: self.idx + 1,
value: self.value.clone(),
}
}
}
pub struct LazyFcn {
pub(crate) core: Arc<Core>,
pub(crate) node: ExprId,
pub(crate) source: Option<ExprId>,
pub(crate) bounds: Vec<BoundVal>,
pub(crate) body: ExprId,
pub(crate) env: Env,
pub(crate) st: St,
pub(crate) rec_slot: Option<usize>,
pub(crate) excepts: Vec<Except>,
pub(crate) materialized: Materialized,
}
#[derive(Debug, Default)]
pub(crate) struct Materialized {
ordinary: OnceLock<Value>,
foreign: Mutex<Option<(u64, Value)>>,
}
impl Clone for Materialized {
fn clone(&self) -> Self {
Self {
ordinary: self.ordinary.clone(),
foreign: Mutex::new(
self.foreign
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone(),
),
}
}
}
impl Materialized {
pub(crate) fn get(&self, domain: u64) -> Option<Value> {
if domain == 0 {
return self.ordinary.get().cloned();
}
let foreign = self.foreign.lock().unwrap_or_else(PoisonError::into_inner);
foreign
.as_ref()
.and_then(|(d, v)| (*d == domain).then(|| v.clone()))
}
pub(crate) fn set(&self, domain: u64, v: Value) {
if domain == 0 {
let _ = self.ordinary.set(v);
} else {
let mut foreign = self.foreign.lock().unwrap_or_else(PoisonError::into_inner);
if foreign.as_ref().is_none_or(|(d, _)| *d != domain) {
*foreign = Some((domain, v));
}
}
}
}
impl fmt::Debug for LazyFcn {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("LazyFcn")
.field("node", &self.node)
.field("bounds", &self.bounds)
.field("excepts", &self.excepts.len())
.finish_non_exhaustive()
}
}
impl LazyFcn {
pub(crate) fn arity(&self) -> usize {
self.bounds
.iter()
.map(|b| if b.tuple { 1 } else { b.slots.len() })
.sum()
}
pub(crate) fn with_except(self: &Arc<Self>, ex: Except) -> Arc<Self> {
let mut excepts = self.excepts.clone();
excepts.push(ex);
Arc::new(Self {
core: self.core.clone(),
node: self.node,
source: None,
bounds: self.bounds.clone(),
body: self.body,
env: self.env.clone(),
st: self.st.clone(),
rec_slot: self.rec_slot,
excepts,
materialized: Materialized::default(),
})
}
pub(crate) fn body_env(self: &Arc<Self>) -> Env {
let mut env = self.env.clone();
if let Some(slot) = self.rec_slot {
env.bind(slot, Sv::Fcn(self.clone()));
}
env
}
pub(crate) fn diagnostic_copy(self: &Arc<Self>) -> Arc<Self> {
Arc::new(Self {
core: self.core.clone(),
node: self.node,
source: None,
bounds: self.bounds.clone(),
body: self.body,
env: self.env.clone(),
st: self.st.diagnostic(),
rec_slot: self.rec_slot,
excepts: self.excepts.clone(),
materialized: self.materialized.clone(),
})
}
}
pub(crate) struct Filter {
pub(crate) core: Arc<Core>,
pub(crate) node: ExprId,
pub(crate) slots: Vec<usize>,
pub(crate) tuple: bool,
pub(crate) in_val: Value,
pub(crate) pred: ExprId,
pub(crate) env: Env,
pub(crate) st: St,
}
impl fmt::Debug for Filter {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Filter")
.field("node", &self.node)
.finish_non_exhaustive()
}
}
pub(crate) fn to_value_error(e: EvalError) -> ValueError {
crate::error::stash(e)
}
impl DeferredSet for Filter {
fn kind(&self) -> DeferredKind {
DeferredKind::Filter
}
fn elements(&self, _ctx: Ctx) -> VResult<Vec<Value>> {
self.core.filter_elements(self).map_err(to_value_error)
}
fn member(&self, elem: &Value, _ctx: Ctx) -> Option<VResult<bool>> {
Some(self.core.filter_member(self, elem).map_err(to_value_error))
}
fn key(&self) -> Vec<Value> {
vec![self.in_val.clone(), Value::Int(i64::from(self.pred.0))]
}
fn as_any(&self) -> Option<&dyn std::any::Any> {
Some(self)
}
}
pub(crate) struct SetOp {
pub(crate) core: Arc<Core>,
pub(crate) kind: DeferredKind,
pub(crate) a: Value,
pub(crate) b: Value,
}
impl fmt::Debug for SetOp {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SetOp")
.field("kind", &self.kind)
.finish_non_exhaustive()
}
}
#[must_use]
pub fn deferred_filter_normalization_operand(provider: &dyn DeferredSet) -> Option<&Value> {
let any: &dyn std::any::Any = provider;
if let Some(filter) = any.downcast_ref::<Filter>() {
Some(&filter.in_val)
} else {
None
}
}
impl DeferredSet for SetOp {
fn kind(&self) -> DeferredKind {
self.kind
}
fn elements(&self, _ctx: Ctx) -> VResult<Vec<Value>> {
self.core.setop_elements(self).map_err(to_value_error)
}
fn member(&self, elem: &Value, ctx: Ctx) -> Option<VResult<bool>> {
Some(match self.kind {
DeferredKind::Cup => tlc::member(elem, &self.a, ctx).and_then(|m| {
if m {
Ok(true)
} else {
tlc::member(elem, &self.b, ctx)
}
}),
DeferredKind::Cap => tlc::member(elem, &self.a, ctx).and_then(|m| {
if m {
tlc::member(elem, &self.b, ctx)
} else {
Ok(false)
}
}),
DeferredKind::Diff => tlc::member(elem, &self.a, ctx).and_then(|m| {
if m {
tlc::member(elem, &self.b, ctx).map(|n| !n)
} else {
Ok(false)
}
}),
DeferredKind::Union => self
.core
.union_member(&self.a, elem)
.map_err(to_value_error),
DeferredKind::Filter | DeferredKind::Map => Ok(false),
})
}
fn key(&self) -> Vec<Value> {
vec![self.a.clone(), self.b.clone()]
}
fn as_any(&self) -> Option<&dyn std::any::Any> {
Some(self)
}
}
#[cfg(test)]
#[path = "recursive_tests.rs"]
mod recursive_tests;