use super::notation::TEXT;
use super::{Sequent, TermId};
use std::fmt::{Display, Formatter, Result as FmtResult};
#[derive(Clone, Copy, Debug)]
pub struct Formula<'a> {
sequent: &'a Sequent,
id: TermId,
}
#[derive(Clone, Copy, Debug)]
pub(crate) enum Stop<T> {
Enter(T, bool),
Between(T),
Exit(T, bool),
}
#[derive(Clone, Copy, Debug)]
enum Step<T> {
Enter(T, bool),
Second(T, bool),
Exit(T, bool),
}
const INLINE: usize = 16;
pub(crate) struct Stops<T, F> {
inline: [Step<T>; INLINE],
len: usize,
spilled: Vec<Step<T>>,
operands: F,
}
impl<T: Copy, F: Fn(T) -> (Option<T>, Option<T>)> Stops<T, F> {
pub(crate) fn new(root: T, nested: bool, operands: F) -> Self {
Self {
inline: [Step::Enter(root, nested); INLINE],
len: 1,
spilled: Vec::new(),
operands,
}
}
fn push(&mut self, step: Step<T>) {
if self.len < INLINE {
self.inline[self.len] = step;
self.len += 1;
} else {
self.spilled.push(step);
}
}
}
impl<T: Copy, F: Fn(T) -> (Option<T>, Option<T>)> Iterator for Stops<T, F> {
type Item = Stop<T>;
fn next(&mut self) -> Option<Stop<T>> {
let step = match self.spilled.pop() {
Some(step) => step,
None => {
self.len = self.len.checked_sub(1)?;
self.inline[self.len]
}
};
Some(match step {
Step::Enter(formula, nested) => {
match (self.operands)(formula) {
(Some(first), Some(_)) => {
self.push(Step::Second(formula, nested));
self.push(Step::Enter(first, true));
}
(Some(only), None) | (None, Some(only)) => {
self.push(Step::Exit(formula, nested));
self.push(Step::Enter(only, true));
}
(None, None) => {}
}
Stop::Enter(formula, nested)
}
Step::Second(formula, nested) => {
self.push(Step::Exit(formula, nested));
if let (_, Some(second)) = (self.operands)(formula) {
self.push(Step::Enter(second, true));
}
Stop::Between(formula)
}
Step::Exit(formula, nested) => Stop::Exit(formula, nested),
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Visit<T> {
Enter(T),
Between(T, u32),
Exit(T),
}
pub struct Walk<'a, T> {
stops: Stops<T, Operands<'a, T>>,
}
type Operands<'a, T> = Box<dyn Fn(T) -> (Option<T>, Option<T>) + 'a>;
impl<'a, T: Copy> Walk<'a, T> {
pub(crate) fn new(root: T, operands: impl Fn(T) -> (Option<T>, Option<T>) + 'a) -> Self {
Self {
stops: Stops::new(root, false, Box::new(operands)),
}
}
}
impl<T: Copy> Iterator for Walk<'_, T> {
type Item = Visit<T>;
fn next(&mut self) -> Option<Visit<T>> {
Some(match self.stops.next()? {
Stop::Enter(formula, _) => Visit::Enter(formula),
Stop::Between(formula) => Visit::Between(formula, 1),
Stop::Exit(formula, _) => Visit::Exit(formula),
})
}
}
impl<T> std::fmt::Debug for Walk<'_, T> {
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
f.write_str("Walk")
}
}
impl Sequent {
#[cfg_attr(feature = "parse", doc = "```")]
#[cfg_attr(not(feature = "parse"), doc = "```ignore")]
pub fn walk(&self, id: TermId) -> Walk<'_, TermId> {
debug_assert!(id.index() < self.terms.len());
Walk::new(id, |k| self.term(k).operands())
}
pub fn formula(&self, id: TermId) -> Formula<'_> {
debug_assert!(id.index() < self.terms.len());
Formula { sequent: self, id }
}
}
impl Display for Formula<'_> {
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
TEXT.term(f, self.sequent, self.id, false)
}
}
impl Display for Sequent {
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
TEXT.one_sided(f, self)
}
}