Skip to main content

logicaffeine_language/
debug.rs

1//! Debug display utilities for AST types with interner access.
2//!
3//! This module provides the [`DisplayWith`] trait for formatting AST types that
4//! contain interned symbols. Since symbols are just integer IDs, displaying them
5//! requires access to the interner to resolve the actual strings.
6//!
7//! Use the `.with(interner)` method to create a displayable wrapper:
8//!
9//! ```
10//! use logicaffeine_base::Interner;
11//! use logicaffeine_language::ast::{LogicExpr, Term};
12//! use logicaffeine_language::debug::DisplayWith;
13//!
14//! let mut interner = Interner::new();
15//! let mortal = interner.intern("Mortal");
16//! let socrates = interner.intern("Socrates");
17//! let args = [Term::Constant(socrates)];
18//! let expr = LogicExpr::Predicate { name: mortal, args: &args, world: None };
19//! assert_eq!(expr.with(&interner).to_string(), "Mortal(Socrates)");
20//! ```
21
22use std::fmt;
23
24use crate::ast::{
25    AspectOperator, BinaryTemporalOp, LogicExpr, NounPhrase, QuantifierKind, TemporalOperator,
26    Term, VoiceOperator,
27};
28use crate::token::TokenType;
29use logicaffeine_base::{Interner, Symbol};
30
31/// Trait for formatting types that require an interner for symbol resolution.
32pub trait DisplayWith {
33    fn fmt_with(&self, interner: &Interner, f: &mut fmt::Formatter<'_>) -> fmt::Result;
34
35    fn with<'a>(&'a self, interner: &'a Interner) -> WithInterner<'a, Self> {
36        WithInterner {
37            target: self,
38            interner,
39        }
40    }
41}
42
43pub struct WithInterner<'a, T: ?Sized> {
44    pub target: &'a T,
45    pub interner: &'a Interner,
46}
47
48impl<'a, T: DisplayWith> fmt::Display for WithInterner<'a, T> {
49    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
50        self.target.fmt_with(self.interner, f)
51    }
52}
53
54pub struct DebugWorld<'a, T: ?Sized> {
55    pub target: &'a T,
56    pub interner: &'a Interner,
57}
58
59impl<'a, T: DisplayWith> fmt::Debug for DebugWorld<'a, T> {
60    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
61        self.target.fmt_with(self.interner, f)
62    }
63}
64
65impl DisplayWith for Symbol {
66    fn fmt_with(&self, interner: &Interner, f: &mut fmt::Formatter<'_>) -> fmt::Result {
67        write!(f, "{}", interner.resolve(*self))
68    }
69}
70
71impl<'a> DisplayWith for Term<'a> {
72    fn fmt_with(&self, interner: &Interner, f: &mut fmt::Formatter<'_>) -> fmt::Result {
73        match self {
74            Term::Constant(s) => write!(f, "{}", interner.resolve(*s)),
75            Term::Variable(s) => write!(f, "{}", interner.resolve(*s)),
76            Term::Function(name, args) => {
77                write!(f, "{}(", interner.resolve(*name))?;
78                for (i, arg) in args.iter().enumerate() {
79                    if i > 0 {
80                        write!(f, ", ")?;
81                    }
82                    arg.fmt_with(interner, f)?;
83                }
84                write!(f, ")")
85            }
86            Term::Group(members) => {
87                write!(f, "[")?;
88                for (i, m) in members.iter().enumerate() {
89                    if i > 0 {
90                        write!(f, " ⊕ ")?;
91                    }
92                    m.fmt_with(interner, f)?;
93                }
94                write!(f, "]")
95            }
96            Term::Possessed {
97                possessor,
98                possessed,
99            } => {
100                possessor.fmt_with(interner, f)?;
101                write!(f, ".{}", interner.resolve(*possessed))
102            }
103            Term::Sigma(predicate) => {
104                write!(f, "σx.{}(x)", interner.resolve(*predicate))
105            }
106            Term::Intension(predicate) => {
107                write!(f, "^{}", interner.resolve(*predicate))
108            }
109            Term::Kind(kind) => {
110                write!(f, "^{}", interner.resolve(*kind))
111            }
112            Term::Proposition(expr) => {
113                write!(f, "[{}]", expr.with(interner))
114            }
115            Term::Value {
116                kind,
117                unit,
118                dimension,
119            } => {
120                use crate::ast::NumberKind;
121                match kind {
122                    NumberKind::Real(r) => write!(f, "{}", r)?,
123                    NumberKind::Integer(i) => write!(f, "{}", i)?,
124                    NumberKind::Symbolic(s) => write!(f, "{}", interner.resolve(*s))?,
125                }
126                if let Some(u) = unit {
127                    write!(f, " {}", interner.resolve(*u))?;
128                }
129                if let Some(d) = dimension {
130                    write!(f, " [{:?}]", d)?;
131                }
132                Ok(())
133            }
134        }
135    }
136}
137
138impl<'a> DisplayWith for NounPhrase<'a> {
139    fn fmt_with(&self, interner: &Interner, f: &mut fmt::Formatter<'_>) -> fmt::Result {
140        if let Some(def) = &self.definiteness {
141            write!(f, "{:?} ", def)?;
142        }
143        for adj in self.adjectives {
144            write!(f, "{} ", interner.resolve(*adj))?;
145        }
146        write!(f, "{}", interner.resolve(self.noun))
147    }
148}
149
150// The notation's operator symbols — one table, read by every renderer (this Display, the
151// Studio's syntax tree), so the two never spell one operator two ways.
152
153/// A quantifier's symbol, with its count for the numeric ones (`∃=2`, `∃≥3`).
154pub fn quantifier_symbol(kind: &QuantifierKind) -> String {
155    match kind {
156        QuantifierKind::Universal => "∀".to_string(),
157        QuantifierKind::Existential => "∃".to_string(),
158        QuantifierKind::Most => "MOST".to_string(),
159        QuantifierKind::Few => "FEW".to_string(),
160        QuantifierKind::Many => "MANY".to_string(),
161        QuantifierKind::Generic => "Gen".to_string(),
162        QuantifierKind::InfinitelyMany => "∃^∞".to_string(),
163        QuantifierKind::FinitelyMany => "∃^<∞".to_string(),
164        QuantifierKind::AllButFinitelyMany => "∀^∞".to_string(),
165        QuantifierKind::Cardinal(n) => format!("∃={n}"),
166        QuantifierKind::AtLeast(n) => format!("∃≥{n}"),
167        QuantifierKind::AtMost(n) => format!("∃≤{n}"),
168    }
169}
170
171/// A connective's symbol, from the one mapping every printer shares ([`Connective::of`](crate::formatter::Connective::of)).
172pub fn connective_symbol(op: &TokenType) -> &'static str {
173    use crate::formatter::Connective;
174    match Connective::of(op) {
175        Some(Connective::And) => "∧",
176        Some(Connective::Or) => "∨",
177        Some(Connective::Implies) => "→",
178        Some(Connective::Iff) => "↔",
179        Some(Connective::Not) => "¬",
180        None => "?",
181    }
182}
183
184/// A modal's operator. The boundary must match the formatter (formatter.rs) and the Kripke
185/// lowering (semantics/kripke.rs): force == 0.5 (ability/epistemic can/could/may) is the
186/// weak/possibility side (◇), not necessity.
187pub fn modal_symbol(vector: &crate::ast::ModalVector) -> &'static str {
188    match (vector.domain, vector.force > 0.5) {
189        (crate::ast::ModalDomain::Alethic, true) => "□",
190        (crate::ast::ModalDomain::Alethic, false) => "◇",
191        (crate::ast::ModalDomain::Deontic, true) => "O",
192        (crate::ast::ModalDomain::Deontic, false) => "P",
193        (crate::ast::ModalDomain::Temporal, _) => "Temporal",
194    }
195}
196
197/// A tense operator: `P` past, `F` future or eventually, `G` always, `X` next.
198pub fn temporal_symbol(op: &TemporalOperator) -> &'static str {
199    match op {
200        TemporalOperator::Past => "P",
201        TemporalOperator::Future => "F",
202        TemporalOperator::Always => "G",
203        TemporalOperator::Eventually | TemporalOperator::BoundedEventually(_) => "F",
204        TemporalOperator::Next => "X",
205    }
206}
207
208/// A binary temporal operator: until, release, weak until.
209pub fn binary_temporal_symbol(op: &BinaryTemporalOp) -> &'static str {
210    match op {
211        BinaryTemporalOp::Until => "U",
212        BinaryTemporalOp::Release => "R",
213        BinaryTemporalOp::WeakUntil => "W",
214    }
215}
216
217/// An aspect operator.
218pub fn aspect_symbol(op: &AspectOperator) -> &'static str {
219    match op {
220        AspectOperator::Progressive => "PROG",
221        AspectOperator::Perfect => "PERF",
222        AspectOperator::Habitual => "HAB",
223        AspectOperator::Iterative => "ITER",
224    }
225}
226
227/// A voice operator.
228pub fn voice_symbol(op: &VoiceOperator) -> &'static str {
229    match op {
230        VoiceOperator::Passive => "PASS",
231    }
232}
233
234/// A focus particle.
235pub fn focus_symbol(kind: &crate::token::FocusKind) -> &'static str {
236    match kind {
237        crate::token::FocusKind::Only => "ONLY",
238        crate::token::FocusKind::Even => "EVEN",
239        crate::token::FocusKind::Just => "JUST",
240        crate::token::FocusKind::Cleft => "CLEFT",
241    }
242}
243
244impl<'a> DisplayWith for LogicExpr<'a> {
245    fn fmt_with(&self, interner: &Interner, f: &mut fmt::Formatter<'_>) -> fmt::Result {
246        match self {
247            LogicExpr::Predicate { name, args, .. } => {
248                write!(f, "{}(", interner.resolve(*name))?;
249                for (i, arg) in args.iter().enumerate() {
250                    if i > 0 {
251                        write!(f, ", ")?;
252                    }
253                    arg.fmt_with(interner, f)?;
254                }
255                write!(f, ")")
256            }
257            LogicExpr::Identity { left, right } => {
258                left.fmt_with(interner, f)?;
259                write!(f, " = ")?;
260                right.fmt_with(interner, f)
261            }
262            LogicExpr::Metaphor { tenor, vehicle } => {
263                write!(f, "Metaphor(")?;
264                tenor.fmt_with(interner, f)?;
265                write!(f, ", ")?;
266                vehicle.fmt_with(interner, f)?;
267                write!(f, ")")
268            }
269            LogicExpr::Quantifier {
270                kind,
271                variable,
272                body,
273                ..
274            } => {
275                write!(
276                    f,
277                    "{}{}.{}",
278                    quantifier_symbol(kind),
279                    interner.resolve(*variable),
280                    body.with(interner)
281                )
282            }
283            LogicExpr::Categorical(data) => {
284                let q = match &data.quantifier {
285                    TokenType::All => "All",
286                    TokenType::Some => "Some",
287                    TokenType::No => "No",
288                    _ => "?",
289                };
290                let cop = if data.copula_negative {
291                    "are not"
292                } else {
293                    "are"
294                };
295                write!(
296                    f,
297                    "{} {} {} {}",
298                    q,
299                    data.subject.with(interner),
300                    cop,
301                    data.predicate.with(interner)
302                )
303            }
304            LogicExpr::Relation(data) => {
305                write!(
306                    f,
307                    "{}({}, {})",
308                    interner.resolve(data.verb),
309                    data.subject.with(interner),
310                    data.object.with(interner)
311                )
312            }
313            LogicExpr::Modal { vector, operand } => {
314                write!(f, "{}({})", modal_symbol(vector), operand.with(interner))
315            }
316            LogicExpr::Temporal { operator, body } => {
317                write!(f, "{}({})", temporal_symbol(operator), body.with(interner))
318            }
319            LogicExpr::Aspectual { operator, body } => {
320                write!(f, "{}({})", aspect_symbol(operator), body.with(interner))
321            }
322            LogicExpr::Voice { operator, body } => {
323                write!(f, "{}({})", voice_symbol(operator), body.with(interner))
324            }
325            LogicExpr::BinaryOp { left, op, right } => {
326                write!(
327                    f,
328                    "({} {} {})",
329                    left.with(interner),
330                    connective_symbol(op),
331                    right.with(interner)
332                )
333            }
334            LogicExpr::UnaryOp { op, operand } => {
335                write!(f, "{}({})", connective_symbol(op), operand.with(interner))
336            }
337            LogicExpr::Question { wh_variable, body } => {
338                write!(
339                    f,
340                    "?{}.{}",
341                    interner.resolve(*wh_variable),
342                    body.with(interner)
343                )
344            }
345            LogicExpr::YesNoQuestion { body } => {
346                write!(f, "?{}", body.with(interner))
347            }
348            LogicExpr::Atom(s) => write!(f, "{}", interner.resolve(*s)),
349            LogicExpr::Lambda { variable, body } => {
350                write!(
351                    f,
352                    "λ{}.{}",
353                    interner.resolve(*variable),
354                    body.with(interner)
355                )
356            }
357            LogicExpr::App { function, argument } => {
358                write!(
359                    f,
360                    "({})({})",
361                    function.with(interner),
362                    argument.with(interner)
363                )
364            }
365            LogicExpr::Intensional { operator, content } => {
366                write!(
367                    f,
368                    "{}({})",
369                    interner.resolve(*operator),
370                    content.with(interner)
371                )
372            }
373            LogicExpr::Event { predicate, adverbs } => {
374                predicate.fmt_with(interner, f)?;
375                for adv in *adverbs {
376                    write!(f, "[{}]", interner.resolve(*adv))?;
377                }
378                Ok(())
379            }
380            LogicExpr::NeoEvent(data) => {
381                write!(
382                    f,
383                    "∃{}({}({})",
384                    interner.resolve(data.event_var),
385                    interner.resolve(data.verb),
386                    interner.resolve(data.event_var)
387                )?;
388                for (role, term) in data.roles.iter() {
389                    write!(
390                        f,
391                        " ∧ {:?}({}, {})",
392                        role,
393                        interner.resolve(data.event_var),
394                        term.with(interner)
395                    )?;
396                }
397                for mod_sym in data.modifiers.iter() {
398                    write!(
399                        f,
400                        " ∧ {}({})",
401                        interner.resolve(*mod_sym),
402                        interner.resolve(data.event_var)
403                    )?;
404                }
405                write!(f, ")")
406            }
407            LogicExpr::Imperative { action } => {
408                write!(f, "!({})", action.with(interner))
409            }
410            LogicExpr::Exclamative { degree_var, body } => {
411                write!(
412                    f,
413                    "Exclaim(∃{}({} ∧ {} ≫ θ))",
414                    interner.resolve(*degree_var),
415                    body.with(interner),
416                    interner.resolve(*degree_var)
417                )
418            }
419            LogicExpr::Optative { wish } => {
420                write!(f, "Wish(Speaker, ⟨{}⟩)", wish.with(interner))
421            }
422            LogicExpr::Implicature {
423                assertion,
424                implicature,
425            } => {
426                write!(
427                    f,
428                    "{} +> Implicature({})",
429                    assertion.with(interner),
430                    implicature.with(interner)
431                )
432            }
433            LogicExpr::SpeechAct {
434                performer,
435                act_type,
436                content,
437            } => {
438                write!(
439                    f,
440                    "{}:{}({})",
441                    interner.resolve(*performer),
442                    interner.resolve(*act_type),
443                    content.with(interner)
444                )
445            }
446            LogicExpr::Counterfactual {
447                antecedent,
448                consequent,
449            } => {
450                write!(
451                    f,
452                    "({} □→ {})",
453                    antecedent.with(interner),
454                    consequent.with(interner)
455                )
456            }
457            LogicExpr::Causal { effect, cause } => {
458                write!(
459                    f,
460                    "Cause({}, {})",
461                    cause.with(interner),
462                    effect.with(interner)
463                )
464            }
465            LogicExpr::Concessive { main, concession } => {
466                write!(
467                    f,
468                    "{} ∧ Concessive({})",
469                    main.with(interner),
470                    concession.with(interner)
471                )
472            }
473            LogicExpr::Comparative {
474                adjective,
475                subject,
476                object,
477                difference,
478                ..
479            } => {
480                if let Some(diff) = difference {
481                    write!(
482                        f,
483                        "{}({}, {}, by: {})",
484                        interner.resolve(*adjective),
485                        subject.with(interner),
486                        object.with(interner),
487                        diff.with(interner)
488                    )
489                } else {
490                    write!(
491                        f,
492                        "{}({}, {})",
493                        interner.resolve(*adjective),
494                        subject.with(interner),
495                        object.with(interner)
496                    )
497                }
498            }
499            LogicExpr::Superlative {
500                adjective,
501                subject,
502                domain,
503            } => {
504                write!(
505                    f,
506                    "MOST-{}({}, {})",
507                    interner.resolve(*adjective),
508                    subject.with(interner),
509                    interner.resolve(*domain)
510                )
511            }
512            LogicExpr::Scopal { operator, body } => {
513                write!(
514                    f,
515                    "{}({})",
516                    interner.resolve(*operator),
517                    body.with(interner)
518                )
519            }
520            LogicExpr::Control {
521                verb,
522                subject,
523                object,
524                infinitive,
525            } => {
526                write!(f, "{}(", interner.resolve(*verb))?;
527                subject.fmt_with(interner, f)?;
528                if let Some(obj) = object {
529                    write!(f, ", ")?;
530                    obj.fmt_with(interner, f)?;
531                }
532                write!(f, ", {})", infinitive.with(interner))
533            }
534            LogicExpr::Presupposition {
535                assertion,
536                presupposition,
537            } => {
538                write!(
539                    f,
540                    "[{} | {}]",
541                    assertion.with(interner),
542                    presupposition.with(interner)
543                )
544            }
545            LogicExpr::Focus {
546                kind,
547                focused,
548                scope,
549            } => {
550                write!(f, "{}[", focus_symbol(kind))?;
551                focused.fmt_with(interner, f)?;
552                write!(f, "]({})", scope.with(interner))
553            }
554            LogicExpr::TemporalAnchor { anchor, body } => {
555                write!(f, "@{}({})", interner.resolve(*anchor), body.with(interner))
556            }
557            LogicExpr::Distributive { predicate } => {
558                write!(f, "*")?;
559                predicate.fmt_with(interner, f)
560            }
561            LogicExpr::GroupQuantifier {
562                group_var,
563                count,
564                member_var,
565                restriction,
566                body,
567            } => {
568                write!(
569                    f,
570                    "∃{}(Group({}) ∧ Count({}, {}) ∧ ∀{}(Member({}, {}) → ",
571                    interner.resolve(*group_var),
572                    interner.resolve(*group_var),
573                    interner.resolve(*group_var),
574                    count,
575                    interner.resolve(*member_var),
576                    interner.resolve(*member_var),
577                    interner.resolve(*group_var)
578                )?;
579                restriction.fmt_with(interner, f)?;
580                write!(f, ") ∧ ")?;
581                body.fmt_with(interner, f)?;
582                write!(f, ")")
583            }
584            LogicExpr::TemporalBinary {
585                operator,
586                left,
587                right,
588            } => {
589                write!(
590                    f,
591                    "({} {} {})",
592                    left.with(interner),
593                    binary_temporal_symbol(operator),
594                    right.with(interner)
595                )
596            }
597        }
598    }
599}
600
601#[cfg(test)]
602#[path = "../../logicaffeine_tests/unit/logicaffeine_language/debug/tests.rs"]
603mod tests;
604
605#[cfg(test)]
606#[path = "../../logicaffeine_tests/unit/logicaffeine_language/debug/connective_symbol_tests.rs"]
607mod connective_symbol_tests;