1use std::fmt::Write;
28
29use crate::ast::logic::NumberKind;
30use crate::ast::{LogicExpr, NounPhrase, QuantifierKind, Term};
31use crate::formatter::{
32 KripkeFormatter, LatexFormatter, LogicFormatter, SimpleFOLFormatter, UnicodeFormatter,
33};
34use crate::registry::SymbolRegistry;
35use crate::token::TokenType;
36use crate::{OutputFormat, TranspileContext};
37use logicaffeine_base::{Interner, Symbol};
38
39fn collect_suppress_existential_events<'a>(expr: &LogicExpr<'a>) -> Vec<Symbol> {
42 let mut events = Vec::new();
43 collect_suppress_existential_events_inner(expr, &mut events);
44 let mut unique = Vec::new();
47 for e in events {
48 if !unique.iter().any(|x| *x == e) {
49 unique.push(e);
50 }
51 }
52 unique
53}
54
55fn collect_suppress_existential_events_inner<'a>(expr: &LogicExpr<'a>, events: &mut Vec<Symbol>) {
56 match expr {
57 LogicExpr::NeoEvent(data) => {
58 if data.suppress_existential {
59 events.push(data.event_var);
60 }
61 }
62 LogicExpr::BinaryOp { left, right, .. } => {
63 collect_suppress_existential_events_inner(left, events);
64 collect_suppress_existential_events_inner(right, events);
65 }
66 LogicExpr::UnaryOp { operand, .. } => {
67 collect_suppress_existential_events_inner(operand, events);
68 }
69 LogicExpr::Temporal { body, .. } => {
70 collect_suppress_existential_events_inner(body, events);
71 }
72 LogicExpr::TemporalBinary { left, right, .. } => {
73 collect_suppress_existential_events_inner(left, events);
74 collect_suppress_existential_events_inner(right, events);
75 }
76 LogicExpr::Aspectual { body, .. } => {
77 collect_suppress_existential_events_inner(body, events);
78 }
79 LogicExpr::Modal { operand, .. } => {
80 collect_suppress_existential_events_inner(operand, events);
81 }
82 _ => {}
83 }
84}
85
86pub fn capitalize_first(s: &str) -> String {
90 let mut chars = s.chars();
91 match chars.next() {
92 None => String::new(),
93 Some(c) => c.to_uppercase().collect::<String>() + chars.as_str(),
94 }
95}
96
97fn write_capitalized<W: Write>(w: &mut W, s: &str) -> std::fmt::Result {
98 let mut chars = s.chars();
99 match chars.next() {
100 None => Ok(()),
101 Some(c) => {
102 for uc in c.to_uppercase() {
103 write!(w, "{}", uc)?;
104 }
105 write!(w, "{}", chars.as_str())
106 }
107 }
108}
109
110impl<'a> NounPhrase<'a> {
111 pub fn to_symbol(&self, registry: &mut SymbolRegistry, interner: &Interner) -> String {
113 registry.get_symbol(self.noun, interner)
114 }
115
116 pub fn to_symbol_full(&self, registry: &SymbolRegistry, interner: &Interner) -> String {
118 registry.get_symbol_full(self.noun, interner)
119 }
120}
121
122impl<'a> Term<'a> {
123 pub fn write_to<W: Write>(
125 &self,
126 w: &mut W,
127 registry: &mut SymbolRegistry,
128 interner: &Interner,
129 ) -> std::fmt::Result {
130 self.write_to_inner(w, registry, interner, false)
131 }
132
133 pub fn write_to_full<W: Write>(
135 &self,
136 w: &mut W,
137 registry: &mut SymbolRegistry,
138 interner: &Interner,
139 ) -> std::fmt::Result {
140 self.write_to_inner(w, registry, interner, true)
141 }
142
143 pub fn write_to_raw<W: Write>(&self, w: &mut W, interner: &Interner) -> std::fmt::Result {
145 match self {
146 Term::Constant(name) | Term::Variable(name) => {
147 write!(w, "{}", interner.resolve(*name))
148 }
149 Term::Function(name, args) => {
150 write!(w, "{}(", interner.resolve(*name))?;
151 for (i, arg) in args.iter().enumerate() {
152 if i > 0 {
153 write!(w, ", ")?;
154 }
155 arg.write_to_raw(w, interner)?;
156 }
157 write!(w, ")")
158 }
159 Term::Group(members) => {
160 write!(w, "(")?;
161 for (i, m) in members.iter().enumerate() {
162 if i > 0 {
163 write!(w, ", ")?;
164 }
165 m.write_to_raw(w, interner)?;
166 }
167 write!(w, ")")
168 }
169 Term::Possessed {
170 possessor,
171 possessed,
172 } => {
173 possessor.write_to_raw(w, interner)?;
174 write!(w, ".{}", interner.resolve(*possessed))
175 }
176 Term::Value { kind, .. } => match kind {
177 NumberKind::Integer(n) => write!(w, "{}", n),
178 NumberKind::Real(f) => write!(w, "{}", f),
179 NumberKind::Symbolic(s) => write!(w, "{}", interner.resolve(*s)),
180 },
181 Term::Sigma(predicate) => write!(w, "σ({})", interner.resolve(*predicate)),
182 Term::Intension(predicate) => write!(w, "^{}", interner.resolve(*predicate)),
183 Term::Kind(kind) => write!(w, "^{}", interner.resolve(*kind)),
184 Term::Proposition(_expr) => write!(w, "[proposition]"),
185 }
186 }
187
188 fn write_to_inner<W: Write>(
189 &self,
190 w: &mut W,
191 registry: &mut SymbolRegistry,
192 interner: &Interner,
193 use_full_names: bool,
194 ) -> std::fmt::Result {
195 match self {
196 Term::Constant(name) => {
197 if use_full_names {
198 write!(w, "{}", registry.get_symbol_full(*name, interner))
199 } else {
200 write!(w, "{}", registry.get_symbol(*name, interner))
201 }
202 }
203 Term::Variable(name) => write!(w, "{}", interner.resolve(*name)),
204 Term::Function(name, args) => {
205 let fn_name = if use_full_names {
206 registry.get_symbol_full(*name, interner)
207 } else {
208 registry.get_symbol(*name, interner)
209 };
210 write!(w, "{}(", fn_name)?;
211 for (i, arg) in args.iter().enumerate() {
212 if i > 0 {
213 write!(w, ", ")?;
214 }
215 arg.write_to_inner(w, registry, interner, use_full_names)?;
216 }
217 write!(w, ")")
218 }
219 Term::Group(members) => {
220 for (i, m) in members.iter().enumerate() {
221 if i > 0 {
222 write!(w, " ⊕ ")?;
223 }
224 m.write_to_inner(w, registry, interner, use_full_names)?;
225 }
226 Ok(())
227 }
228 Term::Possessed {
229 possessor,
230 possessed,
231 } => {
232 let poss_name = if use_full_names {
233 registry.get_symbol_full(*possessed, interner)
234 } else {
235 registry.get_symbol(*possessed, interner)
236 };
237 write!(w, "Poss(")?;
238 possessor.write_to_inner(w, registry, interner, use_full_names)?;
239 write!(w, ", {})", poss_name)
240 }
241 Term::Sigma(predicate) => {
242 let pred_name = if use_full_names {
243 registry.get_symbol_full(*predicate, interner)
244 } else {
245 registry.get_symbol(*predicate, interner)
246 };
247 write!(w, "σ{}", pred_name)
248 }
249 Term::Intension(predicate) => {
250 let word = interner.resolve(*predicate);
252 let capitalized = word
253 .chars()
254 .next()
255 .map(|c| c.to_uppercase().collect::<String>() + &word[1..])
256 .unwrap_or_default();
257 write!(w, "^{}", capitalized)
258 }
259 Term::Kind(kind) => {
260 let word = interner.resolve(*kind);
262 let capitalized = word
263 .chars()
264 .next()
265 .map(|c| c.to_uppercase().collect::<String>() + &word[1..])
266 .unwrap_or_default();
267 write!(w, "^{}", capitalized)
268 }
269 Term::Proposition(expr) => {
270 write!(w, "[")?;
271 expr.write_logic(w, registry, interner, &UnicodeFormatter)?;
272 write!(w, "]")
273 }
274 Term::Value {
275 kind,
276 unit,
277 dimension: _,
278 } => {
279 use crate::ast::NumberKind;
280 match kind {
281 NumberKind::Real(r) => write!(w, "{}", r)?,
282 NumberKind::Integer(i) => write!(w, "{}", i)?,
283 NumberKind::Symbolic(s) => write!(w, "{}", interner.resolve(*s))?,
284 }
285 if let Some(u) = unit {
286 write!(w, " {}", interner.resolve(*u))?;
287 }
288 Ok(())
289 }
290 }
291 }
292
293 pub fn transpile(&self, registry: &mut SymbolRegistry, interner: &Interner) -> String {
295 let mut buf = String::new();
296 let _ = self.write_to(&mut buf, registry, interner);
297 buf
298 }
299}
300
301fn collect_discourse_conjuncts<'a>(expr: &'a LogicExpr<'a>) -> Vec<&'a LogicExpr<'a>> {
304 let mut conjuncts = Vec::new();
305 collect_discourse_conjuncts_inner(expr, &mut conjuncts);
306 conjuncts
307}
308
309fn collect_discourse_conjuncts_inner<'a>(
310 expr: &'a LogicExpr<'a>,
311 conjuncts: &mut Vec<&'a LogicExpr<'a>>,
312) {
313 match expr {
314 LogicExpr::BinaryOp {
315 left,
316 op: TokenType::And,
317 right,
318 } => {
319 collect_discourse_conjuncts_inner(left, conjuncts);
321 collect_discourse_conjuncts_inner(right, conjuncts);
322 }
323 _ => {
324 conjuncts.push(expr);
326 }
327 }
328}
329
330impl<'a> LogicExpr<'a> {
331 pub fn transpile_discourse(
340 &self,
341 registry: &mut SymbolRegistry,
342 interner: &Interner,
343 format: OutputFormat,
344 ) -> String {
345 let conjuncts = collect_discourse_conjuncts(self);
346
347 if conjuncts.len() <= 1 {
348 return self.transpile(registry, interner, format);
350 }
351
352 let mut result = String::new();
354 for (i, conjunct) in conjuncts.iter().enumerate() {
355 if i > 0 {
356 result.push('\n');
357 }
358 let formula = conjunct.transpile(registry, interner, format);
359 result.push_str(&format!("{}) {}", i + 1, formula));
360 }
361 result
362 }
363
364 pub fn write_logic<W: Write, F: LogicFormatter>(
365 &self,
366 w: &mut W,
367 registry: &mut SymbolRegistry,
368 interner: &Interner,
369 fmt: &F,
370 ) -> std::fmt::Result {
371 match self {
372 LogicExpr::Predicate { name, args, world } => {
373 let pred_name = if fmt.use_full_names() {
374 registry.get_symbol_full(*name, interner)
375 } else {
376 registry.get_symbol(*name, interner)
377 };
378
379 if fmt.include_world_arguments() {
381 if let Some(w_sym) = world {
382 let mut extended: Vec<Term> = args.to_vec();
384 extended.push(Term::Variable(*w_sym));
385 return fmt.write_predicate(w, &pred_name, &extended, registry, interner);
386 }
387 }
388 fmt.write_predicate(w, &pred_name, args, registry, interner)
389 }
390
391 LogicExpr::Identity { left, right } => {
392 if fmt.wrap_identity() {
393 write!(w, "(")?;
394 }
395 if fmt.preserve_case() {
396 left.write_to_raw(w, interner)?;
397 } else if fmt.use_full_names() {
398 left.write_to_full(w, registry, interner)?;
399 } else {
400 left.write_to(w, registry, interner)?;
401 }
402 write!(w, "{}", fmt.identity())?;
403 if fmt.preserve_case() {
404 right.write_to_raw(w, interner)?;
405 } else if fmt.use_full_names() {
406 right.write_to_full(w, registry, interner)?;
407 } else {
408 right.write_to(w, registry, interner)?;
409 }
410 if fmt.wrap_identity() {
411 write!(w, ")")?;
412 }
413 Ok(())
414 }
415
416 LogicExpr::Metaphor { tenor, vehicle } => {
417 write!(w, "Metaphor(")?;
418 tenor.write_to(w, registry, interner)?;
419 write!(w, ", ")?;
420 vehicle.write_to(w, registry, interner)?;
421 write!(w, ")")
422 }
423
424 LogicExpr::Quantifier {
425 kind,
426 variable,
427 body,
428 ..
429 } => {
430 let var_str = interner.resolve(*variable);
431
432 if fmt.use_simple_events()
434 && (var_str == "e"
435 || var_str.starts_with("e")
436 && var_str[1..].chars().all(|c| c.is_ascii_digit()))
437 {
438 return body.write_logic(w, registry, interner, fmt);
439 }
440
441 let mut body_buf = String::new();
442 body.write_logic(&mut body_buf, registry, interner, fmt)?;
443 write!(w, "{}", fmt.quantifier(kind, var_str, &body_buf))
444 }
445
446 LogicExpr::Categorical(data) => {
447 let s = if fmt.use_full_names() {
448 fmt.sanitize(&data.subject.to_symbol_full(registry, interner))
449 } else {
450 fmt.sanitize(&data.subject.to_symbol(registry, interner))
451 };
452 let p = if fmt.use_full_names() {
453 fmt.sanitize(&data.predicate.to_symbol_full(registry, interner))
454 } else {
455 fmt.sanitize(&data.predicate.to_symbol(registry, interner))
456 };
457 match (&data.quantifier, data.copula_negative) {
458 (TokenType::All, false) => {
459 write!(w, "{} {} is {}", fmt.categorical_all(), s, p)
460 }
461 (TokenType::No, false) => write!(w, "{} {} is {}", fmt.categorical_no(), s, p),
462 (TokenType::Some, false) => {
463 write!(w, "{} {} is {}", fmt.categorical_some(), s, p)
464 }
465 (TokenType::Some, true) => write!(
466 w,
467 "{} {} is {} {}",
468 fmt.categorical_some(),
469 s,
470 fmt.categorical_not(),
471 p
472 ),
473 (TokenType::All, true) => write!(
474 w,
475 "{} {} is {} {}",
476 fmt.categorical_some(),
477 s,
478 fmt.categorical_not(),
479 p
480 ),
481 _ => write!(w, "Invalid Syllogism"),
482 }
483 }
484
485 LogicExpr::Relation(data) => {
486 let s = if fmt.use_full_names() {
487 data.subject.to_symbol_full(registry, interner)
488 } else {
489 data.subject.to_symbol(registry, interner)
490 };
491 let v = if fmt.use_full_names() {
492 fmt.sanitize(®istry.get_symbol_full(data.verb, interner))
493 } else {
494 fmt.sanitize(®istry.get_symbol(data.verb, interner))
495 };
496 let o = if fmt.use_full_names() {
497 data.object.to_symbol_full(registry, interner)
498 } else {
499 data.object.to_symbol(registry, interner)
500 };
501 write!(w, "{}({}, {})", v, s, o)
502 }
503
504 LogicExpr::Modal { vector, operand } => {
505 let mut o = String::new();
506 operand.write_logic(&mut o, registry, interner, fmt)?;
507 if vector.flavor == crate::ast::ModalFlavor::Evidential {
511 let source = match vector.modal_base {
512 Some(base) if fmt.use_full_names() => {
513 registry.get_symbol_full(base, interner)
514 }
515 Some(base) => registry.get_symbol(base, interner),
516 None => "Seem".to_string(),
517 };
518 return write!(w, "{}([{}])", source, o);
519 }
520 write!(w, "{}", fmt.modal(vector.domain, vector.force, &o))
521 }
522
523 LogicExpr::BinaryOp { left, op, right } => {
524 let mut l = String::new();
525 let mut r = String::new();
526 left.write_logic(&mut l, registry, interner, fmt)?;
527 right.write_logic(&mut r, registry, interner, fmt)?;
528
529 if matches!(op, TokenType::If | TokenType::Implies) {
532 let events = collect_suppress_existential_events(self);
533 if !events.is_empty() {
534 let mut result = fmt.binary_op(op, &l, &r);
536 for event_var in events.into_iter().rev() {
537 let var_str = interner.resolve(event_var);
538 result = fmt.quantifier(&QuantifierKind::Universal, var_str, &result);
539 }
540 return write!(w, "{}", result);
541 }
542 }
543
544 write!(w, "{}", fmt.binary_op(op, &l, &r))
545 }
546
547 LogicExpr::UnaryOp { op, operand } => {
548 let mut o = String::new();
549 operand.write_logic(&mut o, registry, interner, fmt)?;
550 write!(w, "{}", fmt.unary_op(op, &o))
551 }
552
553 LogicExpr::Temporal { operator, body } => {
554 let mut inner = String::new();
555 body.write_logic(&mut inner, registry, interner, fmt)?;
556 write!(w, "{}", fmt.temporal(operator, &inner))
557 }
558
559 LogicExpr::TemporalBinary {
560 operator,
561 left,
562 right,
563 } => {
564 let mut l = String::new();
565 let mut r = String::new();
566 left.write_logic(&mut l, registry, interner, fmt)?;
567 right.write_logic(&mut r, registry, interner, fmt)?;
568 write!(w, "{}", fmt.temporal_binary(operator, &l, &r))
569 }
570
571 LogicExpr::Aspectual { operator, body } => {
572 let mut inner = String::new();
573 body.write_logic(&mut inner, registry, interner, fmt)?;
574 write!(w, "{}", fmt.aspectual(operator, &inner))
575 }
576
577 LogicExpr::Voice { operator, body } => {
578 let mut inner = String::new();
579 body.write_logic(&mut inner, registry, interner, fmt)?;
580 write!(w, "{}", fmt.voice(operator, &inner))
581 }
582
583 LogicExpr::Question { wh_variable, body } => {
584 let mut body_str = String::new();
585 body.write_logic(&mut body_str, registry, interner, fmt)?;
586 write!(
587 w,
588 "{}",
589 fmt.lambda(interner.resolve(*wh_variable), &body_str)
590 )
591 }
592
593 LogicExpr::YesNoQuestion { body } => {
594 write!(w, "?")?;
595 body.write_logic(w, registry, interner, fmt)
596 }
597
598 LogicExpr::Atom(s) => {
599 let name = if fmt.preserve_case() {
600 interner.resolve(*s).to_string()
601 } else if fmt.use_full_names() {
602 registry.get_symbol_full(*s, interner)
603 } else {
604 registry.get_symbol(*s, interner)
605 };
606 write!(w, "{}", fmt.sanitize(&name))
607 }
608
609 LogicExpr::Lambda { variable, body } => {
610 let mut b = String::new();
611 body.write_logic(&mut b, registry, interner, fmt)?;
612 write!(w, "{}", fmt.lambda(interner.resolve(*variable), &b))
613 }
614
615 LogicExpr::App { function, argument } => {
616 write!(w, "(")?;
617 function.write_logic(w, registry, interner, fmt)?;
618 write!(w, ")(")?;
619 argument.write_logic(w, registry, interner, fmt)?;
620 write!(w, ")")
621 }
622
623 LogicExpr::Intensional { operator, content } => {
624 write!(
625 w,
626 "{}[",
627 fmt.sanitize(®istry.get_symbol(*operator, interner))
628 )?;
629 content.write_logic(w, registry, interner, fmt)?;
630 write!(w, "]")
631 }
632
633 LogicExpr::Event { predicate, adverbs } => {
634 let mut pred_str = String::new();
635 predicate.write_logic(&mut pred_str, registry, interner, fmt)?;
636 let adverb_preds: Vec<String> = adverbs
637 .iter()
638 .map(|a| format!("{}(e)", fmt.sanitize(®istry.get_symbol(*a, interner))))
639 .collect();
640 write!(w, "{}", fmt.event_quantifier(&pred_str, &adverb_preds))
641 }
642
643 LogicExpr::NeoEvent(data) => {
644 use crate::ast::{QuantifierKind, ThematicRole};
645
646 if fmt.use_simple_events() {
647 let tenses: Vec<&'static str> = data
651 .modifiers
652 .iter()
653 .filter_map(|m| match interner.resolve(*m) {
654 "Past" => Some(fmt.past()),
655 "Future" => Some(fmt.future()),
656 _ => None,
657 })
658 .collect();
659 for tense in &tenses {
660 write!(w, "{tense}(")?;
661 }
662 write!(w, "{}", registry.get_symbol_full(data.verb, interner))?;
663 write!(w, "(")?;
664 let mut first = true;
665 let mut subject_term = None;
666 for (role, term) in data.roles.iter() {
667 if matches!(
669 role,
670 ThematicRole::Agent
671 | ThematicRole::Patient
672 | ThematicRole::Theme
673 | ThematicRole::Goal
674 | ThematicRole::Location
675 ) {
676 if !first {
677 write!(w, ", ")?;
678 }
679 first = false;
680 term.write_to_full(w, registry, interner)?;
681 if subject_term.is_none() || matches!(role, ThematicRole::Agent) {
684 subject_term = Some(term);
685 }
686 }
687 }
688 write!(w, ")")?;
689 for mod_sym in data
693 .modifiers
694 .iter()
695 .filter(|m| !matches!(interner.resolve(**m), "Past" | "Future"))
696 {
697 write!(w, " {} ", fmt.and())?;
698 write_capitalized(w, interner.resolve(*mod_sym))?;
699 write!(w, "(")?;
700 if let Some(term) = subject_term {
701 term.write_to_full(w, registry, interner)?;
702 }
703 write!(w, ")")?;
704 }
705 for _ in &tenses {
706 write!(w, ")")?;
707 }
708 Ok(())
709 } else {
710 let e = interner.resolve(data.event_var);
711 let mut body = String::new();
712
713 let world_suffix = if fmt.include_world_arguments() {
715 data.world
716 .map(|w| format!(", {}", interner.resolve(w)))
717 .unwrap_or_default()
718 } else {
719 String::new()
720 };
721
722 write_capitalized(&mut body, interner.resolve(data.verb))?;
723 write!(body, "({}{})", e, world_suffix)?;
724 for (role, term) in data.roles.iter() {
725 let role_str = role.name();
726 write!(body, " {} {}({}, ", fmt.and(), role_str, e)?;
727 if fmt.use_full_names() {
728 term.write_to_full(&mut body, registry, interner)?;
729 } else {
730 term.write_to(&mut body, registry, interner)?;
731 }
732 write!(body, "{})", world_suffix)?;
733 }
734 for mod_sym in data.modifiers.iter() {
735 write!(body, " {} ", fmt.and())?;
736 write_capitalized(&mut body, interner.resolve(*mod_sym))?;
737 write!(body, "({}{})", e, world_suffix)?;
738 }
739 if data.suppress_existential {
740 write!(w, "{}", body)
742 } else {
743 write!(
745 w,
746 "{}",
747 fmt.quantifier(&QuantifierKind::Existential, e, &body)
748 )
749 }
750 }
751 }
752
753 LogicExpr::Imperative { action } => {
754 use crate::ast::ThematicRole;
759 fn directive_agent<'b>(e: &'b LogicExpr<'b>) -> Option<&'b Term<'b>> {
760 match e {
761 LogicExpr::NeoEvent(data) => data
762 .roles
763 .iter()
764 .find(|(role, _)| matches!(role, ThematicRole::Agent))
765 .map(|(_, term)| term),
766 LogicExpr::UnaryOp { operand, .. } => directive_agent(operand),
767 LogicExpr::Quantifier { body, .. } => directive_agent(body),
768 LogicExpr::BinaryOp { left, .. } => directive_agent(left),
769 _ => None,
770 }
771 }
772 let mut addressee = String::new();
773 match directive_agent(action) {
774 Some(t) if fmt.use_full_names() => {
775 t.write_to_full(&mut addressee, registry, interner)?
776 }
777 Some(t) => t.write_to(&mut addressee, registry, interner)?,
778 None => addressee.push_str("Addressee"),
779 }
780 let mut a = String::new();
781 action.write_logic(&mut a, registry, interner, fmt)?;
782 write!(w, "Directive({}, [{}])", addressee, a)
783 }
784
785 LogicExpr::Exclamative { degree_var, body } => {
786 let d = interner.resolve(*degree_var);
788 write!(w, "Exclaim(∃{}(", d)?;
789 body.write_logic(w, registry, interner, fmt)?;
790 write!(w, " {} {} ≫ θ))", fmt.and(), d)
791 }
792
793 LogicExpr::Optative { wish } => {
794 write!(w, "Wish(Speaker, ⟨")?;
796 wish.write_logic(w, registry, interner, fmt)?;
797 write!(w, "⟩)")
798 }
799
800 LogicExpr::Implicature {
801 assertion,
802 implicature,
803 } => {
804 assertion.write_logic(w, registry, interner, fmt)?;
807 write!(w, " +> Implicature(")?;
808 implicature.write_logic(w, registry, interner, fmt)?;
809 write!(w, ")")
810 }
811
812 LogicExpr::SpeechAct {
813 performer,
814 act_type,
815 content,
816 } => {
817 write!(
820 w,
821 "SpeechAct({}, {}, ",
822 interner.resolve(*act_type),
823 fmt.sanitize(®istry.get_symbol_full(*performer, interner))
824 )?;
825 content.write_logic(w, registry, interner, fmt)?;
826 write!(w, ")")
827 }
828
829 LogicExpr::Counterfactual {
830 antecedent,
831 consequent,
832 } => {
833 let mut a = String::new();
834 let mut c = String::new();
835 antecedent.write_logic(&mut a, registry, interner, fmt)?;
836 consequent.write_logic(&mut c, registry, interner, fmt)?;
837 write!(w, "{}", fmt.counterfactual(&a, &c))
838 }
839
840 LogicExpr::Causal { effect, cause } => {
841 write!(w, "Cause(")?;
842 cause.write_logic(w, registry, interner, fmt)?;
843 write!(w, ", ")?;
844 effect.write_logic(w, registry, interner, fmt)?;
845 write!(w, ")")
846 }
847
848 LogicExpr::Concessive { main, concession } => {
849 main.write_logic(w, registry, interner, fmt)?;
851 write!(w, " {} Concessive(", fmt.and())?;
852 concession.write_logic(w, registry, interner, fmt)?;
853 write!(w, ")")
854 }
855
856 LogicExpr::Comparative {
857 adjective,
858 subject,
859 object,
860 difference,
861 relation,
862 } => {
863 use crate::ast::ComparisonRelation;
864 if !matches!(relation, ComparisonRelation::Greater) {
867 let rel = if matches!(relation, ComparisonRelation::Equal) {
868 "="
869 } else {
870 "≥"
871 };
872 let adj = interner.resolve(*adjective);
873 let mut s = String::new();
874 subject.write_to(&mut s, registry, interner)?;
875 let mut o = String::new();
876 object.write_to(&mut o, registry, interner)?;
877 let cap = adj
878 .chars()
879 .next()
880 .map(|c| c.to_uppercase().collect::<String>() + &adj[1..])
881 .unwrap_or_default();
882 return write!(
883 w,
884 "max{{d:{}({},d)}} {} max{{d:{}({},d)}}",
885 cap, s, rel, cap, o
886 );
887 }
888 let adj = interner.resolve(*adjective);
889 let mut subj_buf = String::new();
890 if fmt.preserve_case() {
891 subject.write_to_raw(&mut subj_buf, interner)?;
892 } else if fmt.use_full_names() {
893 subject.write_to_full(&mut subj_buf, registry, interner)?;
894 } else {
895 subject.write_to(&mut subj_buf, registry, interner)?;
896 }
897 let mut obj_buf = String::new();
898 if fmt.preserve_case() {
899 object.write_to_raw(&mut obj_buf, interner)?;
900 } else if fmt.use_full_names() {
901 object.write_to_full(&mut obj_buf, registry, interner)?;
902 } else {
903 object.write_to(&mut obj_buf, registry, interner)?;
904 }
905 let diff_str = if let Some(diff) = difference {
906 let mut diff_buf = String::new();
907 if fmt.preserve_case() {
908 diff.write_to_raw(&mut diff_buf, interner)?;
909 } else if fmt.use_full_names() {
910 diff.write_to_full(&mut diff_buf, registry, interner)?;
911 } else {
912 diff.write_to(&mut diff_buf, registry, interner)?;
913 }
914 Some(diff_buf)
915 } else {
916 None
917 };
918 fmt.write_comparative(w, adj, &subj_buf, &obj_buf, diff_str.as_deref())
919 }
920
921 LogicExpr::Superlative {
922 adjective,
923 subject,
924 domain,
925 } => {
926 let mut s = String::new();
927 subject.write_to(&mut s, registry, interner)?;
928 let mut d = String::new();
929 write_capitalized(&mut d, interner.resolve(*domain))?;
930 let comp = format!("{}er", interner.resolve(*adjective));
931 write!(w, "{}", fmt.superlative(&comp, &d, &s))
932 }
933
934 LogicExpr::Scopal { operator, body } => {
935 write!(w, "{}(", interner.resolve(*operator))?;
936 body.write_logic(w, registry, interner, fmt)?;
937 write!(w, ")")
938 }
939
940 LogicExpr::TemporalAnchor { anchor, body } => {
941 write!(w, "{}(", interner.resolve(*anchor))?;
942 body.write_logic(w, registry, interner, fmt)?;
943 write!(w, ")")
944 }
945
946 LogicExpr::Control {
947 verb,
948 subject,
949 object,
950 infinitive,
951 } => {
952 write!(
953 w,
954 "{}(",
955 fmt.sanitize(®istry.get_symbol(*verb, interner))
956 )?;
957 subject.write_to(w, registry, interner)?;
958 if let Some(obj) = object {
959 write!(w, ", ")?;
960 obj.write_to(w, registry, interner)?;
961 }
962 write!(w, ", ")?;
963 infinitive.write_logic(w, registry, interner, fmt)?;
964 write!(w, ")")
965 }
966
967 LogicExpr::Presupposition {
968 assertion,
969 presupposition,
970 } => {
971 assertion.write_logic(w, registry, interner, fmt)?;
972 write!(w, " [Presup: ")?;
973 presupposition.write_logic(w, registry, interner, fmt)?;
974 write!(w, "]")
975 }
976
977 LogicExpr::Focus {
978 kind,
979 focused,
980 scope,
981 } => {
982 use crate::token::FocusKind;
983 let prefix = match kind {
984 FocusKind::Only => "Only",
985 FocusKind::Even => "Even",
986 FocusKind::Just => "Just",
987 FocusKind::Cleft => "Cleft",
988 };
989 write!(w, "{}(", prefix)?;
990 focused.write_to(w, registry, interner)?;
991 write!(w, ", ")?;
992 scope.write_logic(w, registry, interner, fmt)?;
993 write!(w, ")")
994 }
995
996 LogicExpr::Distributive { predicate } => {
997 write!(w, "*")?;
998 predicate.write_logic(w, registry, interner, fmt)
999 }
1000
1001 LogicExpr::GroupQuantifier {
1002 group_var,
1003 count,
1004 member_var,
1005 restriction,
1006 body,
1007 } => {
1008 let g = interner.resolve(*group_var);
1009 let x = interner.resolve(*member_var);
1010
1011 write!(
1013 w,
1014 "{}{}(Group({}) {} Count({}, {}) {} {}{}(Member({}, {}) {} ",
1015 fmt.existential(),
1016 g,
1017 g,
1018 fmt.and(),
1019 g,
1020 count,
1021 fmt.and(),
1022 fmt.universal(),
1023 x,
1024 x,
1025 g,
1026 fmt.implies()
1027 )?;
1028
1029 restriction.write_logic(w, registry, interner, fmt)?;
1030
1031 write!(w, ") {} ", fmt.and())?;
1032
1033 body.write_logic(w, registry, interner, fmt)?;
1034
1035 write!(w, ")")
1036 }
1037 }
1038 }
1039
1040 pub fn transpile_with<F: LogicFormatter>(
1042 &self,
1043 registry: &mut SymbolRegistry,
1044 interner: &Interner,
1045 fmt: &F,
1046 ) -> String {
1047 let mut buf = String::new();
1048 let _ = self.write_logic(&mut buf, registry, interner, fmt);
1049 buf
1050 }
1051
1052 pub fn transpile(
1061 &self,
1062 registry: &mut SymbolRegistry,
1063 interner: &Interner,
1064 format: OutputFormat,
1065 ) -> String {
1066 match format {
1067 OutputFormat::Unicode => self.transpile_with(registry, interner, &UnicodeFormatter),
1068 OutputFormat::LaTeX => self.transpile_with(registry, interner, &LatexFormatter),
1069 OutputFormat::SimpleFOL => self.transpile_with(registry, interner, &SimpleFOLFormatter),
1070 OutputFormat::Kripke => self.transpile_with(registry, interner, &KripkeFormatter),
1071 }
1072 }
1073
1074 pub fn transpile_ctx<F: LogicFormatter>(
1076 &self,
1077 ctx: &mut TranspileContext<'_>,
1078 fmt: &F,
1079 ) -> String {
1080 self.transpile_with(ctx.registry, ctx.interner, fmt)
1081 }
1082
1083 pub fn transpile_ctx_unicode(&self, ctx: &mut TranspileContext<'_>) -> String {
1085 self.transpile_ctx(ctx, &UnicodeFormatter)
1086 }
1087
1088 pub fn transpile_ctx_latex(&self, ctx: &mut TranspileContext<'_>) -> String {
1090 self.transpile_ctx(ctx, &LatexFormatter)
1091 }
1092}