Skip to main content

logicaffeine_language/
view.rs

1//! Owned view types for AST serialization and display.
2//!
3//! This module provides "view" versions of AST types that replace interned symbols
4//! with resolved strings. Views are useful for:
5//!
6//! - Serialization (JSON/Serde) without interner dependency
7//! - Pretty-printing and debugging
8//! - UI display where string values are needed
9//!
10//! The conversion functions take an [`Interner`] reference to resolve symbols.
11
12use crate::ast::{
13    AspectOperator, BinaryTemporalOp, LogicExpr, ModalVector, NounPhrase, QuantifierKind,
14    TemporalOperator, Term, ThematicRole, VoiceOperator,
15};
16use crate::lexicon::Definiteness;
17use crate::token::{FocusKind, TokenType};
18use logicaffeine_base::Interner;
19
20/// View of a term with resolved symbol names.
21#[derive(Debug, Clone, PartialEq)]
22pub enum TermView<'a> {
23    Constant(&'a str),
24    Variable(&'a str),
25    Function(&'a str, Vec<TermView<'a>>),
26    Group(Vec<TermView<'a>>),
27    Possessed {
28        possessor: Box<TermView<'a>>,
29        possessed: &'a str,
30    },
31    Sigma(&'a str),
32    Intension(&'a str),
33    Kind(&'a str),
34    Proposition(Box<ExprView<'a>>),
35    Value {
36        kind: NumberKindView<'a>,
37        unit: Option<&'a str>,
38        dimension: Option<crate::ast::Dimension>,
39    },
40}
41
42#[derive(Debug, Clone, PartialEq)]
43pub enum NumberKindView<'a> {
44    Real(f64),
45    Integer(i64),
46    Symbolic(&'a str),
47}
48
49#[derive(Debug, Clone, PartialEq)]
50pub struct NounPhraseView<'a> {
51    pub definiteness: Option<Definiteness>,
52    pub adjectives: Vec<&'a str>,
53    pub noun: &'a str,
54    pub possessor: Option<Box<NounPhraseView<'a>>>,
55    pub pps: Vec<Box<ExprView<'a>>>,
56    pub superlative: Option<&'a str>,
57}
58
59#[derive(Debug, Clone, PartialEq)]
60pub enum ExprView<'a> {
61    Predicate {
62        name: &'a str,
63        args: Vec<TermView<'a>>,
64    },
65    Identity {
66        left: TermView<'a>,
67        right: TermView<'a>,
68    },
69    Metaphor {
70        tenor: TermView<'a>,
71        vehicle: TermView<'a>,
72    },
73    Quantifier {
74        kind: QuantifierKind,
75        variable: &'a str,
76        body: Box<ExprView<'a>>,
77    },
78    Categorical {
79        quantifier: TokenType,
80        subject: NounPhraseView<'a>,
81        copula_negative: bool,
82        predicate: NounPhraseView<'a>,
83    },
84    Relation {
85        subject: NounPhraseView<'a>,
86        verb: &'a str,
87        object: NounPhraseView<'a>,
88    },
89    Modal {
90        vector: ModalVector,
91        operand: Box<ExprView<'a>>,
92    },
93    Temporal {
94        operator: TemporalOperator,
95        body: Box<ExprView<'a>>,
96    },
97    TemporalBinary {
98        operator: BinaryTemporalOp,
99        left: Box<ExprView<'a>>,
100        right: Box<ExprView<'a>>,
101    },
102    Aspectual {
103        operator: AspectOperator,
104        body: Box<ExprView<'a>>,
105    },
106    Voice {
107        operator: VoiceOperator,
108        body: Box<ExprView<'a>>,
109    },
110    BinaryOp {
111        left: Box<ExprView<'a>>,
112        op: TokenType,
113        right: Box<ExprView<'a>>,
114    },
115    UnaryOp {
116        op: TokenType,
117        operand: Box<ExprView<'a>>,
118    },
119    Question {
120        wh_variable: &'a str,
121        body: Box<ExprView<'a>>,
122    },
123    YesNoQuestion {
124        body: Box<ExprView<'a>>,
125    },
126    Atom(&'a str),
127    Lambda {
128        variable: &'a str,
129        body: Box<ExprView<'a>>,
130    },
131    App {
132        function: Box<ExprView<'a>>,
133        argument: Box<ExprView<'a>>,
134    },
135    Intensional {
136        operator: &'a str,
137        content: Box<ExprView<'a>>,
138    },
139    Event {
140        predicate: Box<ExprView<'a>>,
141        adverbs: Vec<&'a str>,
142    },
143    NeoEvent {
144        event_var: &'a str,
145        verb: &'a str,
146        roles: Vec<(ThematicRole, TermView<'a>)>,
147        modifiers: Vec<&'a str>,
148    },
149    Imperative {
150        action: Box<ExprView<'a>>,
151    },
152    Exclamative {
153        degree_var: &'a str,
154        body: Box<ExprView<'a>>,
155    },
156    Optative {
157        wish: Box<ExprView<'a>>,
158    },
159    Implicature {
160        assertion: Box<ExprView<'a>>,
161        implicature: Box<ExprView<'a>>,
162    },
163    SpeechAct {
164        performer: &'a str,
165        act_type: &'a str,
166        content: Box<ExprView<'a>>,
167    },
168    Counterfactual {
169        antecedent: Box<ExprView<'a>>,
170        consequent: Box<ExprView<'a>>,
171    },
172    Causal {
173        effect: Box<ExprView<'a>>,
174        cause: Box<ExprView<'a>>,
175    },
176    Concessive {
177        main: Box<ExprView<'a>>,
178        concession: Box<ExprView<'a>>,
179    },
180    Comparative {
181        adjective: &'a str,
182        subject: TermView<'a>,
183        object: TermView<'a>,
184        difference: Option<Box<TermView<'a>>>,
185    },
186    Superlative {
187        adjective: &'a str,
188        subject: TermView<'a>,
189        domain: &'a str,
190    },
191    Scopal {
192        operator: &'a str,
193        body: Box<ExprView<'a>>,
194    },
195    Control {
196        verb: &'a str,
197        subject: TermView<'a>,
198        object: Option<TermView<'a>>,
199        infinitive: Box<ExprView<'a>>,
200    },
201    Presupposition {
202        assertion: Box<ExprView<'a>>,
203        presupposition: Box<ExprView<'a>>,
204    },
205    Focus {
206        kind: FocusKind,
207        focused: TermView<'a>,
208        scope: Box<ExprView<'a>>,
209    },
210    TemporalAnchor {
211        anchor: &'a str,
212        body: Box<ExprView<'a>>,
213    },
214    Distributive {
215        predicate: Box<ExprView<'a>>,
216    },
217    GroupQuantifier {
218        group_var: &'a str,
219        count: u32,
220        member_var: &'a str,
221        restriction: Box<ExprView<'a>>,
222        body: Box<ExprView<'a>>,
223    },
224}
225
226pub trait Resolve<'a> {
227    type Output;
228    fn resolve(&self, interner: &'a Interner) -> Self::Output;
229}
230
231impl<'a, 'b> Resolve<'a> for Term<'b> {
232    type Output = TermView<'a>;
233
234    fn resolve(&self, interner: &'a Interner) -> TermView<'a> {
235        match self {
236            Term::Constant(s) => TermView::Constant(interner.resolve(*s)),
237            Term::Variable(s) => TermView::Variable(interner.resolve(*s)),
238            Term::Function(name, args) => TermView::Function(
239                interner.resolve(*name),
240                args.iter().map(|a| a.resolve(interner)).collect(),
241            ),
242            Term::Group(members) => {
243                TermView::Group(members.iter().map(|m| m.resolve(interner)).collect())
244            }
245            Term::Possessed {
246                possessor,
247                possessed,
248            } => TermView::Possessed {
249                possessor: Box::new(possessor.resolve(interner)),
250                possessed: interner.resolve(*possessed),
251            },
252            Term::Sigma(predicate) => TermView::Sigma(interner.resolve(*predicate)),
253            Term::Intension(predicate) => TermView::Intension(interner.resolve(*predicate)),
254            Term::Kind(kind) => TermView::Kind(interner.resolve(*kind)),
255            Term::Proposition(expr) => TermView::Proposition(Box::new(expr.resolve(interner))),
256            Term::Value {
257                kind,
258                unit,
259                dimension,
260            } => {
261                use crate::ast::NumberKind;
262                let kind_view = match kind {
263                    NumberKind::Real(r) => NumberKindView::Real(*r),
264                    NumberKind::Integer(i) => NumberKindView::Integer(*i),
265                    NumberKind::Symbolic(s) => NumberKindView::Symbolic(interner.resolve(*s)),
266                };
267                TermView::Value {
268                    kind: kind_view,
269                    unit: unit.map(|u| interner.resolve(u)),
270                    dimension: *dimension,
271                }
272            }
273        }
274    }
275}
276
277impl<'a, 'b> Resolve<'a> for NounPhrase<'b> {
278    type Output = NounPhraseView<'a>;
279
280    fn resolve(&self, interner: &'a Interner) -> NounPhraseView<'a> {
281        NounPhraseView {
282            definiteness: self.definiteness,
283            adjectives: self
284                .adjectives
285                .iter()
286                .map(|s| interner.resolve(*s))
287                .collect(),
288            noun: interner.resolve(self.noun),
289            possessor: self.possessor.map(|p| Box::new(p.resolve(interner))),
290            pps: self
291                .pps
292                .iter()
293                .map(|pp| Box::new(pp.resolve(interner)))
294                .collect(),
295            superlative: self.superlative.map(|s| interner.resolve(s)),
296        }
297    }
298}
299
300impl<'a, 'b> Resolve<'a> for LogicExpr<'b> {
301    type Output = ExprView<'a>;
302
303    fn resolve(&self, interner: &'a Interner) -> ExprView<'a> {
304        match self {
305            LogicExpr::Predicate { name, args, .. } => ExprView::Predicate {
306                name: interner.resolve(*name),
307                args: args.iter().map(|a| a.resolve(interner)).collect(),
308            },
309            LogicExpr::Identity { left, right } => ExprView::Identity {
310                left: left.resolve(interner),
311                right: right.resolve(interner),
312            },
313            LogicExpr::Metaphor { tenor, vehicle } => ExprView::Metaphor {
314                tenor: tenor.resolve(interner),
315                vehicle: vehicle.resolve(interner),
316            },
317            LogicExpr::Quantifier {
318                kind,
319                variable,
320                body,
321                ..
322            } => ExprView::Quantifier {
323                kind: *kind,
324                variable: interner.resolve(*variable),
325                body: Box::new(body.resolve(interner)),
326            },
327            LogicExpr::Categorical(data) => ExprView::Categorical {
328                quantifier: data.quantifier.clone(),
329                subject: data.subject.resolve(interner),
330                copula_negative: data.copula_negative,
331                predicate: data.predicate.resolve(interner),
332            },
333            LogicExpr::Relation(data) => ExprView::Relation {
334                subject: data.subject.resolve(interner),
335                verb: interner.resolve(data.verb),
336                object: data.object.resolve(interner),
337            },
338            LogicExpr::Modal { vector, operand } => ExprView::Modal {
339                vector: *vector,
340                operand: Box::new(operand.resolve(interner)),
341            },
342            LogicExpr::Temporal { operator, body } => ExprView::Temporal {
343                operator: *operator,
344                body: Box::new(body.resolve(interner)),
345            },
346            LogicExpr::TemporalBinary {
347                operator,
348                left,
349                right,
350            } => ExprView::TemporalBinary {
351                operator: *operator,
352                left: Box::new(left.resolve(interner)),
353                right: Box::new(right.resolve(interner)),
354            },
355            LogicExpr::Aspectual { operator, body } => ExprView::Aspectual {
356                operator: *operator,
357                body: Box::new(body.resolve(interner)),
358            },
359            LogicExpr::Voice { operator, body } => ExprView::Voice {
360                operator: *operator,
361                body: Box::new(body.resolve(interner)),
362            },
363            LogicExpr::BinaryOp { left, op, right } => ExprView::BinaryOp {
364                left: Box::new(left.resolve(interner)),
365                op: op.clone(),
366                right: Box::new(right.resolve(interner)),
367            },
368            LogicExpr::UnaryOp { op, operand } => ExprView::UnaryOp {
369                op: op.clone(),
370                operand: Box::new(operand.resolve(interner)),
371            },
372            LogicExpr::Question { wh_variable, body } => ExprView::Question {
373                wh_variable: interner.resolve(*wh_variable),
374                body: Box::new(body.resolve(interner)),
375            },
376            LogicExpr::YesNoQuestion { body } => ExprView::YesNoQuestion {
377                body: Box::new(body.resolve(interner)),
378            },
379            LogicExpr::Atom(s) => ExprView::Atom(interner.resolve(*s)),
380            LogicExpr::Lambda { variable, body } => ExprView::Lambda {
381                variable: interner.resolve(*variable),
382                body: Box::new(body.resolve(interner)),
383            },
384            LogicExpr::App { function, argument } => ExprView::App {
385                function: Box::new(function.resolve(interner)),
386                argument: Box::new(argument.resolve(interner)),
387            },
388            LogicExpr::Intensional { operator, content } => ExprView::Intensional {
389                operator: interner.resolve(*operator),
390                content: Box::new(content.resolve(interner)),
391            },
392            LogicExpr::Event { predicate, adverbs } => ExprView::Event {
393                predicate: Box::new(predicate.resolve(interner)),
394                adverbs: adverbs.iter().map(|s| interner.resolve(*s)).collect(),
395            },
396            LogicExpr::NeoEvent(data) => ExprView::NeoEvent {
397                event_var: interner.resolve(data.event_var),
398                verb: interner.resolve(data.verb),
399                roles: data
400                    .roles
401                    .iter()
402                    .map(|(role, term)| (*role, term.resolve(interner)))
403                    .collect(),
404                modifiers: data
405                    .modifiers
406                    .iter()
407                    .map(|s| interner.resolve(*s))
408                    .collect(),
409            },
410            LogicExpr::Imperative { action } => ExprView::Imperative {
411                action: Box::new(action.resolve(interner)),
412            },
413            LogicExpr::Exclamative { degree_var, body } => ExprView::Exclamative {
414                degree_var: interner.resolve(*degree_var),
415                body: Box::new(body.resolve(interner)),
416            },
417            LogicExpr::Optative { wish } => ExprView::Optative {
418                wish: Box::new(wish.resolve(interner)),
419            },
420            LogicExpr::Implicature {
421                assertion,
422                implicature,
423            } => ExprView::Implicature {
424                assertion: Box::new(assertion.resolve(interner)),
425                implicature: Box::new(implicature.resolve(interner)),
426            },
427            LogicExpr::SpeechAct {
428                performer,
429                act_type,
430                content,
431            } => ExprView::SpeechAct {
432                performer: interner.resolve(*performer),
433                act_type: interner.resolve(*act_type),
434                content: Box::new(content.resolve(interner)),
435            },
436            LogicExpr::Counterfactual {
437                antecedent,
438                consequent,
439            } => ExprView::Counterfactual {
440                antecedent: Box::new(antecedent.resolve(interner)),
441                consequent: Box::new(consequent.resolve(interner)),
442            },
443            LogicExpr::Causal { effect, cause } => ExprView::Causal {
444                effect: Box::new(effect.resolve(interner)),
445                cause: Box::new(cause.resolve(interner)),
446            },
447            LogicExpr::Concessive { main, concession } => ExprView::Concessive {
448                main: Box::new(main.resolve(interner)),
449                concession: Box::new(concession.resolve(interner)),
450            },
451            LogicExpr::Comparative {
452                adjective,
453                subject,
454                object,
455                difference,
456                ..
457            } => ExprView::Comparative {
458                adjective: interner.resolve(*adjective),
459                subject: subject.resolve(interner),
460                object: object.resolve(interner),
461                difference: difference.map(|d| Box::new(d.resolve(interner))),
462            },
463            LogicExpr::Superlative {
464                adjective,
465                subject,
466                domain,
467            } => ExprView::Superlative {
468                adjective: interner.resolve(*adjective),
469                subject: subject.resolve(interner),
470                domain: interner.resolve(*domain),
471            },
472            LogicExpr::Scopal { operator, body } => ExprView::Scopal {
473                operator: interner.resolve(*operator),
474                body: Box::new(body.resolve(interner)),
475            },
476            LogicExpr::Control {
477                verb,
478                subject,
479                object,
480                infinitive,
481            } => ExprView::Control {
482                verb: interner.resolve(*verb),
483                subject: subject.resolve(interner),
484                object: object.map(|o| o.resolve(interner)),
485                infinitive: Box::new(infinitive.resolve(interner)),
486            },
487            LogicExpr::Presupposition {
488                assertion,
489                presupposition,
490            } => ExprView::Presupposition {
491                assertion: Box::new(assertion.resolve(interner)),
492                presupposition: Box::new(presupposition.resolve(interner)),
493            },
494            LogicExpr::Focus {
495                kind,
496                focused,
497                scope,
498            } => ExprView::Focus {
499                kind: *kind,
500                focused: focused.resolve(interner),
501                scope: Box::new(scope.resolve(interner)),
502            },
503            LogicExpr::TemporalAnchor { anchor, body } => ExprView::TemporalAnchor {
504                anchor: interner.resolve(*anchor),
505                body: Box::new(body.resolve(interner)),
506            },
507            LogicExpr::Distributive { predicate } => ExprView::Distributive {
508                predicate: Box::new(predicate.resolve(interner)),
509            },
510            LogicExpr::GroupQuantifier {
511                group_var,
512                count,
513                member_var,
514                restriction,
515                body,
516            } => ExprView::GroupQuantifier {
517                group_var: interner.resolve(*group_var),
518                count: *count,
519                member_var: interner.resolve(*member_var),
520                restriction: Box::new(restriction.resolve(interner)),
521                body: Box::new(body.resolve(interner)),
522            },
523        }
524    }
525}
526
527#[cfg(test)]
528#[path = "../../logicaffeine_tests/unit/logicaffeine_language/view/term_view_tests.rs"]
529mod term_view_tests;
530
531#[cfg(test)]
532#[path = "../../logicaffeine_tests/unit/logicaffeine_language/view/expr_view_tests.rs"]
533mod expr_view_tests;