1use 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#[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;