use super::term::*;
pub fn lit(text: &str) -> Term {
Term::App(format!("lit${text}"), Vec::new())
}
pub fn dec(v: Term) -> Term {
Term::App("dec".into(), vec![v])
}
pub fn btxt(b: Term) -> Term {
Term::App("btxt".into(), vec![b])
}
pub fn fmt(kind: &str, v: Term) -> Term {
Term::App(format!("fmt${kind}"), vec![v])
}
fn lit_text(t: &Term) -> Option<&str> {
match t {
Term::App(n, a) if a.is_empty() => n.strip_prefix("lit$"),
_ => None,
}
}
pub fn out_event(stream: u8, chunks: Vec<Term>) -> Term {
let mut merged: Vec<Term> = Vec::new();
for c in chunks {
match (lit_text(&c), merged.last().and_then(lit_text)) {
(Some(""), _) => {}
(Some(b), Some(a)) => {
let joined = lit(&format!("{a}{b}"));
*merged.last_mut().unwrap() = joined;
}
_ => merged.push(c),
}
}
Term::App(format!("out${stream}"), merged)
}
pub fn call_event(name: &str, args: &[Term]) -> Term {
Term::App(format!("call${name}"), args.to_vec())
}
pub fn finish_atom(name: &str, args: &[Term]) -> Term {
cmp(
COp::Eq,
Term::App(format!("fin${name}"), args.to_vec()),
Term::Int(1),
)
}
pub fn is_bool_term(t: &Term) -> bool {
matches!(
t,
Term::Bool(_)
| Term::Cmp(..)
| Term::Iff(..)
| Term::Not(_)
| Term::And(..)
| Term::Or(..)
| Term::Var(_, super::ty::Ty::Bool)
)
}
fn value_eq(a: &Term, b: &Term) -> Term {
if let (Term::App(na, xa), Term::App(nb, xb)) = (a, b) {
if na.starts_with("agg$") || nb.starts_with("agg$") {
if na != nb || xa.len() != xb.len() {
return Term::Bool(false);
}
return xa
.iter()
.zip(xb)
.fold(Term::Bool(true), |g, (x, y)| and(g, value_eq(x, y)));
}
}
match (is_bool_term(a), is_bool_term(b)) {
(true, true) => iff(a.clone(), b.clone()),
(false, false) => cmp(COp::Eq, a.clone(), b.clone()),
_ => Term::Bool(false),
}
}
pub fn ev_eq(a: &Term, b: &Term) -> Term {
let (Term::App(na, xa), Term::App(nb, xb)) = (a, b) else {
return Term::Bool(false);
};
if na != nb || xa.len() != xb.len() {
return Term::Bool(false);
}
let pairs = xa.iter().zip(xb);
if na.starts_with("out$") {
pairs.fold(Term::Bool(true), |g, (x, y)| and(g, ev_eq(x, y)))
} else if na == "btxt" {
iff(xa[0].clone(), xb[0].clone())
} else {
pairs.fold(Term::Bool(true), |g, (x, y)| and(g, value_eq(x, y)))
}
}