use crate::ctx::Ctx;
use crate::error::{ErrorKind, Result, ValueError};
use crate::tlc::member;
use crate::value::{Set, SetRepr, Value};
fn current(v: &Value, ctx: Ctx) -> Result<(Vec<Value>, bool)> {
match v {
Value::Set(s) => match s.repr() {
SetRepr::Raw(raw) => {
if s.is_tlc_normalized() {
Ok((crate::stream::elems_in(s, ctx, true)?.to_vec(), true))
} else {
Ok((raw.to_vec(), false))
}
}
_ => Ok((crate::stream::elems_in(s, ctx, true)?.to_vec(), true)),
},
_ => Err(ValueError::new(
ErrorKind::Argument,
format!(
"Attempted to apply a set operator to the non-set value\n{}",
crate::print::print_value(v, ctx).unwrap_or_default()
),
)),
}
}
fn build(elems: Vec<Value>, normalized: bool, ctx: Ctx) -> Value {
if normalized {
Value::Set(Set::from_sorted(ctx.order, elems))
} else {
Value::set_raw(elems, ctx)
}
}
pub fn union(a: &Value, b: &Value, ctx: Ctx) -> Result<Value> {
let (mut out, _) = current(a, ctx)?;
if out.is_empty() {
return Ok(b.clone());
}
let Value::Set(bs) = b else {
return current(b, ctx).map(|(_, _)| b.clone());
};
for e in crate::stream::elems_in(bs, ctx, true)?.iter() {
if !member(e, a, ctx)? {
out.push(e.clone());
}
}
Ok(Value::set_raw(out, ctx))
}
pub fn intersect(a: &Value, b: &Value, ctx: Ctx) -> Result<Value> {
let (elems, norm) = current(a, ctx)?;
let mut out = Vec::new();
for e in elems {
if member(&e, b, ctx)? {
out.push(e);
}
}
Ok(build(out, norm, ctx))
}
pub fn difference(a: &Value, b: &Value, ctx: Ctx) -> Result<Value> {
let (elems, norm) = current(a, ctx)?;
let mut out = Vec::new();
for e in elems {
if !member(&e, b, ctx)? {
out.push(e);
}
}
Ok(build(out, norm, ctx))
}
pub fn choose(
s: &Value,
ctx: Ctx,
mut pred: impl FnMut(&Value) -> Result<bool>,
) -> Result<Option<Value>> {
let Value::Set(set) = s else {
return Err(ValueError::new(
ErrorKind::NotEnumerable,
"Attempted to compute the value of an expression of form CHOOSE x \\in S: P, but S was not enumerable.",
));
};
for e in crate::stream::elems_in(set, ctx, true)?.iter() {
if pred(e)? {
return Ok(Some(e.clone()));
}
}
Ok(None)
}