1use 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
31pub 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
150pub 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
171pub 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
184pub 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
197pub 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
208pub 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
217pub 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
227pub fn voice_symbol(op: &VoiceOperator) -> &'static str {
229 match op {
230 VoiceOperator::Passive => "PASS",
231 }
232}
233
234pub 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;