mech_core/
nodes.rs

1use crate::*; 
2#[cfg(feature = "no_std")]
3use core::cmp::Ordering;
4#[cfg(not(feature = "no_std"))] 
5use std::cmp::Ordering;
6
7#[cfg(feature = "serde")]
8pub fn compress_and_encode<T: serde::Serialize>(tree: &T) -> Result<String, Box<dyn std::error::Error>> {
9  let serialized_code = bincode::serde::encode_to_vec(tree,bincode::config::standard())?;
10  let mut compressed = Vec::new();
11  brotli::CompressorWriter::new(&mut compressed, 9, 4096, 22)
12      .write(&serialized_code)?;
13  Ok(base64::encode(compressed))
14}
15
16#[cfg(feature = "serde")]
17pub fn decode_and_decompress<T: serde::de::DeserializeOwned>(encoded: &str) -> Result<T, Box<dyn std::error::Error>> {
18  let decoded = base64::decode(encoded)?;
19  
20  let mut decompressed = Vec::new();
21  brotli::Decompressor::new(Cursor::new(decoded), 4096)
22      .read_to_end(&mut decompressed)?;
23  
24  let (decoded,red) = bincode::serde::decode_from_slice(&decompressed,bincode::config::standard())?;
25
26  Ok(decoded)
27}
28#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
29#[derive(Clone, Copy, PartialEq, Eq, Hash, Ord)]
30pub struct SourceLocation {
31  pub row: usize,
32  pub col: usize,
33}
34
35impl PartialOrd for SourceLocation {
36  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
37    if self.row < other.row {
38      Some(Ordering::Less)
39    } else if self.row > other.row {
40      Some(Ordering::Greater)
41    } else {
42      self.col.partial_cmp(&other.col)
43    }
44  }
45}
46
47impl fmt::Debug for SourceLocation {
48  #[inline]
49  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
50    write!(f, "{}:{}", self.row, self.col);
51    Ok(())
52  }
53}
54
55#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
56#[derive(Clone, Hash, PartialEq, Eq)]
57pub struct SourceRange {
58  pub start: SourceLocation,
59  pub end:   SourceLocation,
60}
61
62/// Coordinates in SourceRange are 1-indexed, i.e. they directly translate
63/// human's view to line and column numbers.  Having value 0 means the 
64/// range is not initialized.
65impl Default for SourceRange {
66  fn default() -> Self {
67    SourceRange {
68      start: SourceLocation { row: 0, col: 0 },
69      end:   SourceLocation { row: 0, col: 0 },
70    }
71  }
72}
73
74impl fmt::Debug for SourceRange {
75  #[inline]
76  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
77    write!(f, "[{:?}, {:?})", self.start, self.end);
78    Ok(())
79  }
80}
81
82pub fn merge_src_range(r1: SourceRange, r2: SourceRange) -> SourceRange {
83  SourceRange {
84    start: r1.start.min(r2.start),
85    end:   r2.end.max(r2.end),
86  }
87}
88
89pub trait Recoverable: Sized {
90  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self;
91}
92
93#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
94#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
95pub enum TokenKind {
96  AbstractSigil, Alpha, Ampersand, Any, Apostrophe, AssignOperator, Asterisk, AsyncTransitionOperator, At,
97  Backslash, Bar, BoxDrawing,
98  Caret, CarriageReturn, CarriageReturnNewLine, Colon, CodeBlock, Comma,
99  Dash, DefineOperator, Digit, Dollar,
100  Emoji, EmphasisSigil, Empty, Equal, EquationSigil, Error, ErrorSigil, EscapedChar, Exclamation, 
101  False, FloatLeft, FloatRight, FootnotePrefix,
102  GenOperator, Grave, GraveCodeBlockSigil,
103  HashTag, HighlightSigil, HttpPrefix,
104  IdeaSigil, Identifier, ImgPrefix, InfoSigil, InlineCode, 
105  LeftAngle, LeftBrace, LeftBracket, LeftParenthesis,
106  #[cfg(feature = "mika")]
107  Mika(Mika), 
108  MikaSection, MikaSectionOpen, MikaSectionClose,
109  Newline, Not, Number,
110  OutputOperator,
111  Percent, Period, Plus, PromptSigil,
112  Question, QuestionSigil, Quote, QuoteSigil,
113  RightAngle, RightBrace, RightBracket, RightParenthesis,
114  SectionSigil, Semicolon, Space, Slash, String, StrikeSigil, StrongSigil, SuccessSigil, SynthOperator,
115  Tab, Text, Tilde, TildeCodeBlockSigil, Title, TransitionOperator, True,
116  UnderlineSigil, Underscore,
117  WarningSigil,
118}
119
120#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
121#[derive(Clone, Hash, PartialEq, Eq)]
122pub struct Token { 
123  pub kind: TokenKind, 
124  pub chars: Vec<char>, 
125  pub src_range: SourceRange 
126}
127
128impl fmt::Debug for Token {
129  #[inline]
130  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
131    write!(f, "{:?}:{:?}:{:?}", self.kind, String::from_iter(self.chars.iter().cloned()), self.src_range);
132    Ok(())
133  }
134}
135
136impl Default for Token {
137  fn default() -> Self {
138    Token{
139      kind: TokenKind::Empty,
140      chars: vec![],
141      src_range: SourceRange::default(),
142    }
143  }
144}
145
146impl Token {
147
148  pub fn new(kind: TokenKind, src_range: SourceRange, chars: Vec<char>) -> Token {
149    Token{kind, chars, src_range}
150  }
151
152  pub fn to_string(&self) -> String {
153    self.chars.iter().collect()
154  }
155
156  pub fn merge_tokens(tokens: &mut Vec<Token>) -> Option<Token> {
157    if tokens.len() == 0 {
158      None
159    } else if tokens.len() == 1 {
160      Some(tokens[0].clone())
161    } else {
162      let first = tokens[0].src_range.clone();
163      let kind = tokens[0].kind.clone();
164      let last = tokens.last().unwrap().src_range.clone();
165      let src_range = merge_src_range(first, last);
166      let chars: Vec<char> = tokens.iter_mut().fold(vec![],|mut m, ref mut t| {m.append(&mut t.chars.clone()); m});
167      let merged_token = Token{kind, chars, src_range};
168      Some(merged_token)
169    }
170  }
171}
172
173#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
174#[derive(Clone, Debug, Hash, PartialEq, Eq)]
175pub struct TableOfContents {
176    pub title: Option<Title>,
177    pub sections: Vec<Section>,
178}
179
180#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
181#[derive(Clone, Debug, Hash, PartialEq, Eq)]
182pub struct Program {
183  pub title: Option<Title>,
184  pub body: Body,
185}
186
187impl Program {
188  pub fn tokens(&self) -> Vec<Token> {
189    /*let mut title_tokens = match self.title.tokens() {
190      Some(tkns) => tkns,
191      None => vec![],
192    };*/
193    let body_tokens = self.body.tokens();
194    body_tokens
195  }
196
197  pub fn table_of_contents(&self) -> TableOfContents {
198    let mut sections = vec![];
199    for s in &self.body.sections {
200      sections.push(s.table_of_contents());
201    }
202    TableOfContents {
203      title: self.title.clone(),
204      sections,
205    }
206  }
207
208}
209
210#[cfg(feature = "pretty_print")]
211impl PrettyPrint for Program {
212fn pretty_print(&self) -> String {
213    #[cfg(feature = "serde")]
214    let json_string = serde_json::to_string_pretty(self).unwrap();
215    #[cfg(not(feature = "serde"))]
216    let json_string = "Error: Enable Serde to prettt print trees.".to_string();
217
218    let depth = |line: &str|->usize{line.chars().take_while(|&c| c == ' ').count()};
219    let mut result = String::new();
220    let lines: Vec<&str> = json_string.lines().collect();
221    result.push_str("Program\n");
222    for (index, line) in lines.iter().enumerate() {
223      let trm = line.trim();
224      if trm == "}" || 
225         trm == "},"|| 
226         trm == "{" || 
227         trm == "[" || 
228         trm == "],"|| 
229         trm == "]" {
230        continue;
231      }
232  
233      // Count leading spaces to determine depth
234      let d = depth(line);
235      // Construct the tree-like prefix
236      let mut prefix = String::new();
237      for _ in 0..d {
238        prefix.push_str(" ");
239      }
240      if index == lines.len() {
241        prefix.push_str("└ ");
242      } else {
243        if depth(lines[index + 1]) != d {
244          prefix.push_str("└ ");
245        } else {
246          prefix.push_str("├ ");
247        }
248      }
249      let trm = line.trim();
250      let trm = trm.trim_end_matches('{')
251                    .trim_start_matches('"')
252                    .trim_end_matches(':')
253                    .trim_end_matches('"')
254                    .trim_end_matches('[');
255      prefix.push_str(trm);
256  
257      // Append formatted line to result
258      result.push_str(&prefix);
259      result.push('\n');
260      result = result.replace("\":", "");
261    }
262    let mut indexed_str = IndexedString::new(&result);
263    'rows: for i in 0..indexed_str.rows {
264      let rowz = &indexed_str.index_map[i];
265      for j in 0..rowz.len() {
266        let c = match indexed_str.get(i,j) {
267          Some(c) => c,
268          None => continue,
269        };
270        if c == '└' {
271          for k in i+1..indexed_str.rows {
272            match indexed_str.get(k,j) {
273              Some(c2) => {
274                if c2 == '└' {
275                  indexed_str.set(i,j,'├');
276                  for l in i+1..k {
277                    match indexed_str.get(l,j) {
278                      Some(' ') => {indexed_str.set(l,j,'│');},
279                      Some('└') => {indexed_str.set(l,j,'├');},
280                      _ => (),
281                    }
282                  }
283                } else if c2 == ' ' {
284                  continue;
285                } else {
286                  continue 'rows;
287                }
288              },
289              None => continue,
290            }
291  
292          }
293        } else if c == ' ' || c == '│' {
294          continue;
295        } else {
296          continue 'rows;
297        }
298      }
299    }
300    indexed_str.to_string()
301  }
302}
303
304#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
305#[derive(Clone, Debug, Hash, PartialEq, Eq)]
306pub struct Title {
307  pub text: Token,
308  pub byline: Option<Paragraph>,
309}
310
311impl Title {
312
313  pub fn to_string(&self) -> String {
314    self.text.to_string()
315  }
316
317}
318
319#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
320#[derive(Clone, Debug, Hash, PartialEq, Eq)]
321pub struct Body {
322  pub sections: Vec<Section>,
323}
324
325impl Body {
326  pub fn tokens(&self) -> Vec<Token> {
327    let mut out = vec![];
328    for s in &self.sections {
329      let mut tkns = s.tokens();
330      out.append(&mut tkns);
331    }
332    out
333  }
334}
335
336#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
337#[derive(Clone, Debug, Hash, PartialEq, Eq)]
338pub enum ColumnAlignment {
339  Left,
340  Center,
341  Right,
342}
343
344#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
345#[derive(Clone, Debug, Hash, PartialEq, Eq)]
346pub struct MarkdownTable {
347  pub header: Vec<Paragraph>,
348  pub rows: Vec<Vec<Paragraph>>,
349  pub alignment: Vec<ColumnAlignment>,
350}
351
352#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
353#[derive(Clone, Debug, Hash, PartialEq, Eq)]
354pub struct Subtitle {
355  pub text: Paragraph,
356  pub level: u8,
357}
358
359impl Subtitle {
360  pub fn to_string(&self) -> String {
361    self.text.to_string()
362  }
363}
364
365#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
366#[derive(Clone, Debug, Hash, PartialEq, Eq)]
367pub struct Section {
368  pub subtitle: Option<Subtitle>,
369  pub elements: Vec<SectionElement>,
370}
371
372impl Section {
373
374  pub fn table_of_contents(&self) -> Section {
375    let elements: Vec<_> = self.elements.iter()
376      .filter(|e| matches!(e, SectionElement::Subtitle(_)))
377      .cloned()
378      .collect();
379    Section {
380      subtitle: self.subtitle.clone(),
381      elements,
382    }
383  }
384
385  pub fn tokens(&self) -> Vec<Token> {
386    let mut out = vec![];
387    for s in &self.elements {
388      let mut tkns = s.tokens();
389      out.append(&mut tkns);
390    }
391    out
392  }
393}
394
395#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
396#[derive(Clone, Debug, Hash, PartialEq, Eq)]
397pub struct Grammar {
398  pub rules: Vec<Rule>,
399}
400
401#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
402#[derive(Clone, Debug, Hash, PartialEq, Eq)]
403pub struct GrammarIdentifier {
404  pub name: Token,
405}
406
407impl GrammarIdentifier {
408  pub fn tokens(&self) -> Vec<Token> {
409    vec![self.name.clone()]
410  }
411
412  pub fn to_string(&self) -> String {
413    self.name.to_string()
414  }
415}
416
417#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
418#[derive(Clone, Debug, Hash, PartialEq, Eq)]
419pub struct Rule {
420  pub name: GrammarIdentifier,
421  pub expr: GrammarExpression,
422}
423
424#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
425#[derive(Clone, Debug, Hash, PartialEq, Eq)]
426pub enum GrammarExpression {
427  Choice(Vec<GrammarExpression>),
428  Definition(GrammarIdentifier),
429  Group(Box<GrammarExpression>),
430  List(Box<GrammarExpression>, Box<GrammarExpression>),
431  Not(Box<GrammarExpression>),
432  Optional(Box<GrammarExpression>),
433  Peek(Box<GrammarExpression>),
434  Repeat0(Box<GrammarExpression>),
435  Repeat1(Box<GrammarExpression>),
436  Range(Token,Token),
437  Sequence(Vec<GrammarExpression>),
438  Terminal(Token),
439}
440
441impl GrammarExpression {
442  pub fn tokens(&self) -> Vec<Token> {
443    match self {
444      GrammarExpression::Choice(exprs) => {
445        let mut tokens = vec![];
446        for expr in exprs {
447          tokens.append(&mut expr.tokens());
448        }
449        tokens
450      }
451      GrammarExpression::Definition(id) => id.tokens(),
452      GrammarExpression::Group(expr) => expr.tokens(),
453      GrammarExpression::List(expr1, expr2) => {
454        let mut tokens = expr1.tokens();
455        tokens.append(&mut expr2.tokens());
456        tokens
457      }
458      GrammarExpression::Not(expr) => expr.tokens(),
459      GrammarExpression::Optional(expr) => expr.tokens(),
460      GrammarExpression::Peek(expr) => expr.tokens(),
461      GrammarExpression::Repeat0(expr) => expr.tokens(),
462      GrammarExpression::Repeat1(expr) => expr.tokens(),
463      GrammarExpression::Range(t1, t2) => vec![t1.clone(), t2.clone()],
464      GrammarExpression::Sequence(exprs) => {
465        let mut tokens = vec![];
466        for expr in exprs {
467          tokens.append(&mut expr.tokens());
468        }
469        tokens
470      }
471      GrammarExpression::Terminal(t) => vec![t.clone()],
472    }
473  }
474
475
476}
477
478#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
479#[derive(Clone, Debug, Hash, PartialEq, Eq)]
480pub struct Citation {
481  pub id: Token,
482  pub text: Paragraph,
483}
484
485impl Citation {
486  pub fn to_string(&self) -> String {
487    format!("[{}]: {}", self.id.to_string(), self.text.to_string())
488  }
489}
490
491// Stores code block configuration
492#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
493#[derive(Clone, Debug, Hash, PartialEq, Eq)]
494pub struct BlockConfig {
495  pub namespace_str: String,
496  pub namespace: u64,
497  pub disabled: bool,
498  pub hidden: bool,
499}
500
501pub type Footnote = (Token, Vec<Paragraph>);
502
503#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
504#[derive(Clone, Debug, Hash, PartialEq, Eq)]
505pub enum FloatDirection {
506  Left,
507  Right,
508}
509
510#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
511#[derive(Clone, Debug, Hash, PartialEq, Eq)]
512pub struct FencedMechCode {
513  pub code: Vec<(MechCode,Option<Comment>)>,
514  pub config: BlockConfig,
515  pub options: Option<OptionMap>,
516}
517
518#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
519#[derive(Clone, Debug, Hash, PartialEq, Eq)]
520pub enum SectionElement {
521  Abstract(Vec<Paragraph>),
522  QuoteBlock(Vec<Paragraph>),
523  InfoBlock(Vec<Paragraph>),
524  SuccessBlock(Vec<Paragraph>),
525  IdeaBlock(Vec<Paragraph>),
526  WarningBlock(Vec<Paragraph>),
527  ErrorBlock(Vec<Paragraph>),
528  QuestionBlock(Vec<Paragraph>),
529  Citation(Citation),
530  CodeBlock(Token),
531  Comment(Comment),
532  Diagram(Token),
533  Equation(Token),
534  FencedMechCode(FencedMechCode),
535  Float((Box<SectionElement>, FloatDirection)),
536  Footnote(Footnote),
537  Grammar(Grammar),
538  Image(Image),
539  List(MDList),
540  MechCode(Vec<(MechCode,Option<Comment>)>),
541  #[cfg(feature = "mika")]
542  Mika((Mika, Option<MikaSection>)),
543  Paragraph(Paragraph),
544  Subtitle(Subtitle),
545  Table(MarkdownTable),
546  Prompt(Box<SectionElement>),
547  ThematicBreak,
548  Error(Token, SourceRange),
549}
550
551impl Recoverable for SectionElement {
552  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
553    SectionElement::Error(skipped_tokens, range)
554  }
555}
556
557impl SectionElement {
558
559  pub fn tokens(&self) -> Vec<Token> {
560    match self {
561      SectionElement::Prompt(prompt) => prompt.tokens(),
562      #[cfg(feature = "mika")]
563      SectionElement::Mika((mika, mika_section)) => {
564        let mut tokens = vec![];
565        tokens.append(&mut mika.tokens());
566        if let Some(mika_section) = mika_section {
567          for mika_section_element in &mika_section.elements.elements {
568            tokens.append(&mut mika_section_element.tokens());
569          }
570        }
571        tokens
572      },
573      SectionElement::FencedMechCode(c) => {
574        let mut tokens = vec![];
575        for (c, _) in &c.code {
576          tokens.append(&mut c.tokens());
577        }
578        tokens
579      }
580      SectionElement::MechCode(codes) => {
581        let mut tokens = vec![];
582        for (code, _) in codes {
583          tokens.append(&mut code.tokens());
584        }
585        tokens
586      }
587      SectionElement::Abstract(paragraphs)
588      | SectionElement::QuoteBlock(paragraphs)
589      | SectionElement::InfoBlock(paragraphs)
590      | SectionElement::SuccessBlock(paragraphs)
591      | SectionElement::IdeaBlock(paragraphs)
592      | SectionElement::WarningBlock(paragraphs)
593      | SectionElement::ErrorBlock(paragraphs)
594      | SectionElement::QuestionBlock(paragraphs) => {
595        let mut tokens = vec![];
596        for paragraph in paragraphs {
597          tokens.append(&mut paragraph.tokens());
598        }
599        tokens
600      }
601      SectionElement::Citation(citation) => citation.text.tokens(),
602      SectionElement::CodeBlock(token)
603      | SectionElement::Diagram(token)
604      | SectionElement::Equation(token) => vec![token.clone()],
605      SectionElement::Comment(comment) => comment.tokens(),
606      SectionElement::Float((element, _)) => element.tokens(),
607      SectionElement::Footnote((_, paragraphs)) => {
608        let mut tokens = vec![];
609        for paragraph in paragraphs {
610          tokens.append(&mut paragraph.tokens());
611        }
612        tokens
613      }
614        SectionElement::Grammar(grammar) => {
615        let mut tokens = vec![];
616        for rule in &grammar.rules {
617          tokens.append(&mut rule.name.tokens());
618          tokens.append(&mut rule.expr.tokens());
619        }
620        tokens
621      }
622      SectionElement::Image(image) => {
623        let mut tokens = vec![image.src.clone()];
624        if let Some(caption) = &image.caption {
625          tokens.append(&mut caption.tokens());
626        }
627        tokens
628      }
629      SectionElement::List(list) => match list {
630      MDList::Unordered(items) => {
631        let mut tokens = vec![];
632        for ((_, paragraph), sublist) in items {
633        tokens.append(&mut paragraph.tokens());
634        if let Some(sublist) = sublist {
635          tokens.append(&mut sublist.tokens());
636        }
637        }
638        tokens
639      }
640      MDList::Ordered(ordered_list) => {
641        let mut tokens = ordered_list.start.tokens();
642        for ((_, paragraph), sublist) in &ordered_list.items {
643        tokens.append(&mut paragraph.tokens());
644        if let Some(sublist) = sublist {
645          tokens.append(&mut sublist.tokens());
646        }
647        }
648        tokens
649      }
650      MDList::Check(items) => {
651        let mut tokens = vec![];
652        for ((_, paragraph), sublist) in items {
653        tokens.append(&mut paragraph.tokens());
654        if let Some(sublist) = sublist {
655          tokens.append(&mut sublist.tokens());
656        }
657        }
658        tokens
659      }
660      },
661      SectionElement::Paragraph(paragraph) => paragraph.tokens(),
662      SectionElement::Subtitle(subtitle) => subtitle.text.tokens(),
663      SectionElement::Table(table) => {
664        let mut tokens = vec![];
665        for header in &table.header {
666          tokens.append(&mut header.tokens());
667        }
668        for row in &table.rows {
669          for column in row {
670          tokens.append(&mut column.tokens());
671          }
672        }
673        tokens
674      }
675      SectionElement::ThematicBreak => vec![],
676      SectionElement::Error(token, _) => vec![token.clone()],
677    }
678  }
679}
680
681
682#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
683#[derive(Clone, Debug, Hash, PartialEq, Eq)]
684pub struct OptionMap {
685  pub elements: Vec<(Identifier, MechString)>,
686}
687
688
689#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
690#[derive(Clone, Debug, Hash, PartialEq, Eq)]
691pub struct Image {
692  pub src: Token,
693  pub caption: Option<Paragraph>,
694  pub style: Option<OptionMap>,
695}
696
697impl Image {
698  pub fn to_string(&self) -> String {
699    let caption = match &self.caption {
700      Some(c) => c.to_string(),
701      None => "".to_string(),
702    };
703    format!("![{}]({})", caption, self.src.to_string())
704  }
705}
706
707pub type UnorderedList = Vec<((Option<Token>,Paragraph),Option<MDList>)>;
708pub type CheckList = Vec<((bool,Paragraph),Option<MDList>)>;
709
710#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
711#[derive(Clone, Debug, Hash, PartialEq, Eq)]
712pub struct OrderedList {
713  pub start: Number,
714  pub items: Vec<((Number,Paragraph),Option<MDList>)>,
715}
716
717#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
718#[derive(Clone, Debug, Hash, PartialEq, Eq)]
719pub enum MDList {
720  Unordered(UnorderedList),
721  Ordered(OrderedList),
722  Check(CheckList)
723}
724
725impl MDList {
726
727  pub fn tokens(&self) -> Vec<Token> {
728    match self {
729      MDList::Unordered(items) => {
730        let mut tokens = vec![];
731        for ((_, paragraph), sublist) in items {
732          tokens.append(&mut paragraph.tokens());
733          if let Some(sublist) = sublist {
734            tokens.append(&mut sublist.tokens());
735          }
736        }
737        tokens
738      }
739      MDList::Ordered(ordered_list) => {
740        let mut tokens = ordered_list.start.tokens();
741        for ((_, paragraph), sublist) in &ordered_list.items {
742          tokens.append(&mut paragraph.tokens());
743          if let Some(sublist) = sublist {
744            tokens.append(&mut sublist.tokens());
745          }
746        }
747        tokens
748      }
749      MDList::Check(items) => {
750        let mut tokens = vec![];
751        for ((_, paragraph), sublist) in items {
752          tokens.append(&mut paragraph.tokens());
753          if let Some(sublist) = sublist {
754            tokens.append(&mut sublist.tokens());
755          }
756        }
757        tokens
758      }
759    }
760  }
761
762}
763
764#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
765#[derive(Clone, Debug, Hash, PartialEq, Eq)]
766pub enum MechCode {
767  Comment(Comment),
768  Expression(Expression),
769  //FsmImplementation(FsmImplementation),
770  //FsmSpecification(FsmSpecification),
771  FunctionDefine(FunctionDefine),
772  Statement(Statement),
773  Error(Token, SourceRange),
774}
775
776impl Recoverable for MechCode {
777  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
778    MechCode::Error(skipped_tokens, range)
779  }
780}
781
782impl MechCode {
783  pub fn tokens(&self) -> Vec<Token> {
784    match self {
785      MechCode::Expression(x) => x.tokens(),
786      MechCode::Statement(x) => x.tokens(),
787      MechCode::Comment(x) => x.tokens(),
788      MechCode::Error(t,_) => vec![t.clone()],
789      _ => todo!(),
790      //FunctionDefine(x) => x.tokens(),
791      //FsmSpecification(x) => x.tokens(),
792      //FsmImplementation(x) => x.tokens(),
793    }
794  }
795}
796
797#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
798#[derive(Clone, Debug, Hash, PartialEq, Eq)]
799pub struct FunctionDefine {
800  pub name: Identifier,
801  pub input: Vec<FunctionArgument>,
802  pub output: Vec<FunctionArgument>,
803  pub statements: Vec<Statement>,
804  pub match_arms: Vec<FunctionMatchArm>,
805}
806
807#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
808#[derive(Clone, Debug, Hash, PartialEq, Eq)]
809pub struct FunctionMatchArm {
810  pub pattern: Pattern,
811  pub expression: Expression,
812}
813
814#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
815#[derive(Clone, Debug, Hash, PartialEq, Eq)]
816pub struct FunctionArgument {
817  pub name: Identifier,
818  pub kind: KindAnnotation,
819}
820
821impl FunctionArgument {
822  pub fn tokens(&self) -> Vec<Token> {
823    let mut tokens = self.name.tokens();
824    tokens.append(&mut self.kind.tokens());
825    tokens
826  }
827}
828
829#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
830#[derive(Clone, Debug, Hash, PartialEq, Eq)]
831pub struct FsmImplementation {
832  pub name: Identifier,
833  pub input: Vec<Identifier>,
834  pub start: Pattern,
835  pub arms: Vec<FsmArm>,
836}
837
838#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
839#[derive(Clone, Debug, Hash, PartialEq, Eq)]
840pub enum FsmArm {
841  Guard(Pattern,Vec<Guard>),
842  Transition(Pattern,Vec<Transition>),
843}
844
845#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
846#[derive(Clone, Debug, Hash, PartialEq, Eq)]
847pub struct Guard { 
848  pub condition: Pattern,
849  pub transitions: Vec<Transition>,
850}
851
852#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
853#[derive(Clone, Debug, Hash, PartialEq, Eq)]
854pub enum Transition {
855  Async(Pattern),
856  CodeBlock(Vec<(MechCode, Option<Comment>)>),
857  Next(Pattern),
858  Output(Pattern),
859  Statement(Statement),
860}
861
862#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
863#[derive(Clone, Debug, Hash, PartialEq, Eq)]
864pub enum Pattern {
865  Expression(Expression),
866  TupleStruct(PatternTupleStruct),
867  Tuple(PatternTuple),
868  Wildcard,
869}
870
871impl Pattern {
872  pub fn tokens(&self) -> Vec<Token> {
873    match self {
874      Pattern::Expression(e) => e.tokens(),
875      Pattern::TupleStruct(ts) => ts.tokens(),
876      Pattern::Tuple(t) => t.tokens(),
877      Pattern::Wildcard => vec![],
878    }
879  }
880}
881
882#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
883#[derive(Clone, Debug, Hash, PartialEq, Eq)]
884pub struct PatternTupleStruct {
885  pub name: Identifier,
886  pub patterns: Vec<Pattern>,
887}
888
889impl PatternTupleStruct {
890  pub fn tokens(&self) -> Vec<Token> {
891    let mut tokens = self.name.tokens();
892    for p in &self.patterns {
893      tokens.append(&mut p.tokens());
894    }
895    tokens
896  }
897}
898
899#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
900#[derive(Clone, Debug, Hash, PartialEq, Eq)]
901pub struct PatternTuple(pub Vec<Pattern>);
902
903impl PatternTuple {
904  pub fn tokens(&self) -> Vec<Token> {
905    let mut tokens = vec![];
906    for p in &self.0 {
907        tokens.append(&mut p.tokens());
908    }
909    tokens
910  }
911}
912
913#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
914#[derive(Clone, Debug, Hash, PartialEq, Eq)]
915pub struct FsmSpecification {
916  pub name: Identifier,
917  pub input: Vec<Var>,
918  pub output: Option<KindAnnotation>,
919  pub states: Vec<StateDefinition>,
920}
921
922#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
923#[derive(Clone, Debug, Hash, PartialEq, Eq)]
924pub struct StateDefinition {
925  pub name: Identifier,
926  pub state_variables: Option<Vec<Var>>,
927}
928
929#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
930#[derive(Clone, Debug, Hash, PartialEq, Eq)]
931pub enum Statement {
932  EnumDefine(EnumDefine),
933  //FsmDeclare(FsmDeclare),
934  KindDefine(KindDefine),
935  OpAssign(OpAssign),
936  VariableAssign(VariableAssign),
937  VariableDefine(VariableDefine),
938  TupleDestructure(TupleDestructure),
939  SplitTable,     // todo
940  FlattenTable,   // todo
941}
942
943impl Statement {
944  pub fn tokens(&self) -> Vec<Token> {
945    match self {
946      Statement::EnumDefine(x) => x.tokens(),
947      //Statement::FsmDeclare(x) => x.tokens(),
948      Statement::KindDefine(x) => x.tokens(),
949      Statement::OpAssign(x) => x.tokens(),
950      Statement::VariableAssign(x) => x.tokens(),
951      Statement::VariableDefine(x) => x.tokens(),
952      Statement::TupleDestructure(x) => x.tokens(),
953      Statement::SplitTable => vec![], // todo
954      Statement::FlattenTable => vec![], // todo
955    }
956  }
957}
958
959#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
960#[derive(Clone, Debug, Hash, PartialEq, Eq)]
961pub struct TupleDestructure {
962  pub vars: Vec<Identifier>,
963  pub expression: Expression,
964}
965
966impl TupleDestructure {
967  pub fn tokens(&self) -> Vec<Token> {
968    let mut tokens = vec![];
969    for var in &self.vars {
970      tokens.append(&mut var.tokens());
971    }
972    tokens.append(&mut self.expression.tokens());
973    tokens
974  }
975}
976
977#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
978#[derive(Clone, Debug, Hash, PartialEq, Eq)]
979pub struct FsmPipe {
980  pub start: FsmInstance,
981  pub transitions: Vec<Transition>
982}
983
984#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
985#[derive(Clone, Debug, Hash, PartialEq, Eq)]
986pub enum PipeElement {
987  Expression(Expression),
988  FsmInstance(FsmInstance),
989  Timer // todo
990}
991
992#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
993#[derive(Clone, Debug, Hash, PartialEq, Eq)]
994pub struct FsmDeclare {
995  pub fsm: Fsm,
996  pub pipe: FsmPipe,
997}
998
999#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1000#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1001pub struct Fsm {
1002  pub name: Identifier,
1003  pub args: Option<ArgumentList>,
1004  pub kind: Option<KindAnnotation>
1005}
1006
1007pub type FsmArgs = Vec<(Option<Identifier>,Expression)>;
1008
1009#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1010#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1011pub struct FsmInstance {
1012  pub name: Identifier,
1013  pub args: Option<FsmArgs>,
1014}
1015
1016#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1017#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1018pub struct EnumDefine {
1019  pub name: Identifier,
1020  pub variants: Vec<EnumVariant>,
1021}
1022
1023impl EnumDefine {
1024  pub fn tokens(&self) -> Vec<Token> {
1025    let mut tokens = self.name.tokens();
1026    for v in &self.variants {
1027      tokens.append(&mut v.tokens());
1028    }
1029    tokens
1030  }
1031}
1032
1033#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1034#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1035pub struct EnumVariant {
1036  pub name: Identifier,
1037  pub value: Option<KindAnnotation>,
1038}
1039
1040impl EnumVariant {
1041  pub fn tokens(&self) -> Vec<Token> {
1042    let mut tokens = self.name.tokens();
1043    if let Some(value) = &self.value {
1044      tokens.append(&mut value.tokens());
1045    }
1046    tokens
1047  }
1048}
1049
1050#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1051#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1052pub struct KindDefine {
1053  pub name: Identifier,
1054  pub kind: KindAnnotation,
1055}
1056
1057impl KindDefine {
1058  pub fn tokens(&self) -> Vec<Token> {
1059    let mut tokens = self.name.tokens();
1060    tokens.append(&mut self.kind.tokens());
1061    tokens
1062  }
1063}
1064
1065#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1066#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1067pub struct Record {
1068  pub bindings: Vec<Binding>,
1069}
1070
1071impl Record {
1072  pub fn tokens(&self) -> Vec<Token> {
1073    let mut tkns = vec![];
1074    for b in &self.bindings {
1075      let mut t = b.tokens();
1076      tkns.append(&mut t);
1077    }
1078    tkns
1079  }
1080}
1081
1082#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1083#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1084pub enum Structure {
1085  Empty,
1086  Map(Map),
1087  Matrix(Matrix),
1088  Record(Record),
1089  Set(Set),
1090  Table(Table),
1091  Tuple(Tuple),
1092  TupleStruct(TupleStruct),
1093}
1094
1095impl Structure {
1096  pub fn tokens(&self) -> Vec<Token> {
1097    match self {
1098      Structure::Empty => vec![],
1099      Structure::Map(map) => map.tokens(),
1100      Structure::Matrix(mat) => mat.tokens(),
1101      Structure::Record(rec) => rec.tokens(),
1102      Structure::Set(set) => set.tokens(),
1103      Structure::Table(tab) => tab.tokens(),
1104      Structure::Tuple(tup) => tup.tokens(),
1105      Structure::TupleStruct(ts) => ts.tokens(),
1106    }
1107  }
1108}
1109
1110#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1111#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1112pub struct Map {
1113  pub elements: Vec<Mapping>,
1114}
1115
1116impl Map {
1117  pub fn tokens(&self) -> Vec<Token> {
1118    let mut tkns = vec![];
1119    for e in &self.elements {
1120      let mut t = e.tokens();
1121      tkns.append(&mut t);
1122    }
1123    tkns
1124  }
1125}
1126
1127#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1128#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1129pub struct Mapping {
1130  pub key: Expression,
1131  pub value: Expression,
1132}
1133
1134impl Mapping {
1135  pub fn tokens(&self) -> Vec<Token> {
1136    let mut tkns = self.key.tokens();
1137    tkns.append(&mut self.value.tokens());
1138    tkns
1139  }
1140}
1141
1142#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1143#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1144pub struct Set {
1145  pub elements: Vec<Expression>,
1146}
1147
1148impl Set {
1149  pub fn tokens(&self) -> Vec<Token> {
1150    let mut tkns = vec![];
1151    for e in &self.elements {
1152      let mut t = e.tokens();
1153      tkns.append(&mut t);
1154    }
1155    tkns
1156  }
1157}
1158
1159#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1160#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1161pub struct Atom {
1162  pub name: Identifier,
1163}
1164
1165impl Atom {
1166  pub fn tokens(&self) -> Vec<Token> {
1167    self.name.tokens()
1168  }
1169}
1170
1171#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1172#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1173pub struct TupleStruct {
1174  pub name: Identifier,
1175  pub value: Box<Expression>,
1176}
1177
1178impl TupleStruct {
1179  pub fn tokens(&self) -> Vec<Token> {
1180    let mut tkns = self.name.tokens();
1181    tkns.append(&mut self.value.tokens());
1182    tkns
1183  }
1184}
1185
1186#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1187#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1188pub struct Matrix {
1189  pub rows: Vec<MatrixRow>,
1190}
1191
1192impl Matrix {
1193  pub fn tokens(&self) -> Vec<Token> {
1194    let mut tkns = vec![];
1195    for r in &self.rows {
1196      let mut t = r.tokens();
1197      tkns.append(&mut t);
1198    }
1199    tkns
1200  }
1201}
1202
1203#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1204#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1205pub struct TableHeader(pub Vec<Field>);
1206
1207impl TableHeader {
1208  pub fn new(fields: Vec<Field>) -> TableHeader {
1209    TableHeader(fields)
1210  }
1211  pub fn tokens(&self) -> Vec<Token> {
1212    let mut tkns = vec![];
1213    for f in &self.0 {
1214      let mut t = f.tokens();
1215      tkns.append(&mut t);
1216    }
1217    tkns
1218  }
1219}
1220
1221#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1222#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1223pub struct Table {
1224  pub header: TableHeader,
1225  pub rows: Vec<TableRow>,
1226}
1227
1228impl Table {
1229  pub fn tokens(&self) -> Vec<Token> {
1230    let mut tkns = vec![];
1231    for f in &self.header.0 {
1232      let mut t = f.tokens();
1233      tkns.append(&mut t);
1234    }
1235    for r in &self.rows {
1236      let mut t = r.tokens();
1237      tkns.append(&mut t);
1238    }
1239    tkns
1240  }
1241}
1242
1243#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1244#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1245pub struct Field {
1246  pub name: Identifier,
1247  pub kind: Option<KindAnnotation>,
1248}
1249
1250impl Field {
1251  pub fn tokens(&self) -> Vec<Token> {
1252    let mut tkns = self.name.tokens();
1253    if let Some(knd) = &self.kind {
1254      let mut t = knd.tokens();
1255      tkns.append(&mut t);
1256    }
1257    tkns
1258  }
1259}
1260
1261#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1262#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1263pub struct TableColumn {
1264  pub element: Expression,
1265}
1266
1267impl TableColumn {
1268  pub fn tokens(&self) -> Vec<Token> {
1269    self.element.tokens()
1270  }
1271}
1272
1273#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1274#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1275pub struct MatrixColumn {
1276  pub element: Expression,
1277}
1278
1279impl MatrixColumn {
1280  pub fn tokens(&self) -> Vec<Token> {
1281    self.element.tokens()
1282  }
1283}
1284
1285#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1286#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1287pub struct TableRow {
1288  pub columns: Vec<TableColumn>,
1289}
1290
1291impl TableRow {
1292  pub fn tokens(&self) -> Vec<Token> {
1293    let mut tkns = vec![];
1294    for r in &self.columns {
1295      let mut t = r.element.tokens();
1296      tkns.append(&mut t);
1297    }
1298    tkns
1299  }
1300}
1301
1302#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1303#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1304pub struct MatrixRow {
1305  pub columns: Vec<MatrixColumn>,
1306}
1307
1308impl MatrixRow {
1309  pub fn tokens(&self) -> Vec<Token> {
1310    let mut tkns = vec![];
1311    for r in &self.columns {
1312      let mut t = r.tokens();
1313      tkns.append(&mut t);
1314    }
1315    tkns
1316  }
1317}
1318
1319#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1320#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1321pub struct VariableDefine {
1322  pub mutable: bool,
1323  pub var: Var,
1324  pub expression: Expression,
1325}
1326
1327impl VariableDefine {
1328  pub fn tokens(&self) -> Vec<Token> {
1329    let mut tkns = self.var.tokens();
1330    tkns.append(&mut self.expression.tokens());
1331    tkns
1332  }
1333}
1334
1335#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1336#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1337pub struct Var {
1338  pub name: Identifier,
1339  pub kind: Option<KindAnnotation>,
1340}
1341
1342impl Var {
1343  pub fn tokens(&self) -> Vec<Token> {
1344    let mut tkns = self.name.tokens();
1345    if let Some(knd) = &self.kind {
1346      let mut t = knd.tokens();
1347      tkns.append(&mut t);
1348    }
1349    tkns
1350  }
1351}
1352
1353#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1354#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1355pub struct VariableAssign {
1356  pub target: SliceRef,
1357  pub expression: Expression,
1358}
1359
1360impl VariableAssign {
1361  pub fn tokens(&self) -> Vec<Token> {
1362    let mut tkns = self.target.tokens();
1363    tkns.append(&mut self.expression.tokens());
1364    tkns
1365  }
1366}
1367
1368#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1369#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1370pub struct Identifier {
1371  pub name: Token,
1372}
1373
1374impl Identifier {
1375  pub fn tokens(&self) -> Vec<Token> {
1376    vec![self.name.clone()]
1377  }
1378
1379  pub fn to_string(&self) -> String {
1380    self.name.to_string()
1381  }
1382
1383}
1384
1385impl Identifier {
1386  pub fn hash(&self) -> u64 {
1387    hash_chars(&self.name.chars)
1388  }
1389}
1390
1391#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1392#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1393pub struct Emoji {
1394  pub tokens: Vec<Token>,
1395}
1396
1397#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1398#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1399pub struct Word {
1400  pub tokens: Vec<Token>,
1401}
1402
1403#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1404#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1405pub struct Slice {
1406  pub name: Identifier,
1407  pub subscript: Vec<Subscript>
1408}
1409
1410impl Slice {
1411  pub fn tokens(&self) -> Vec<Token> {
1412    let mut tkns = self.name.tokens();
1413    for sub in &self.subscript {
1414      let mut sub_tkns = sub.tokens();
1415      tkns.append(&mut sub_tkns);
1416    }
1417    tkns
1418  }
1419}
1420
1421#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1422#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1423pub struct SliceRef {
1424  pub name: Identifier,
1425  pub subscript: Option<Vec<Subscript>>
1426}
1427
1428impl SliceRef {
1429  pub fn tokens(&self) -> Vec<Token> {
1430    let mut tkns = self.name.tokens();
1431    if let Some(subs) = &self.subscript {
1432      for sub in subs {
1433        let mut sub_tkns = sub.tokens();
1434        tkns.append(&mut sub_tkns);
1435      }
1436    }
1437    tkns
1438  }
1439}
1440
1441#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1442#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1443pub enum Subscript {
1444  All,                      // a[:]
1445  Brace(Vec<Subscript>),    // a{"foo"}
1446  Bracket(Vec<Subscript>),  // a[1,2,3]
1447  Dot(Identifier),          // a.b
1448  DotInt(RealNumber),       // a.1
1449  Formula(Factor),          // a[1 + 1]
1450  Range(RangeExpression),   // a[1 + 1]
1451  Swizzle(Vec<Identifier>), // a.b,c
1452}
1453
1454impl Subscript {
1455
1456  pub fn tokens(&self) -> Vec<Token> {
1457    match self {
1458      Subscript::All => vec![
1459        Token::new(TokenKind::Colon, SourceRange::default(), vec![':']),
1460      ],
1461      Subscript::Brace(subs) => {
1462        let mut tkns = vec![Token::new(TokenKind::LeftBrace, SourceRange::default(), vec!['{'])];
1463        for sub in subs {
1464          let mut sub_tkns = sub.tokens();
1465          tkns.append(&mut sub_tkns);
1466        }
1467        tkns.push(Token::new(TokenKind::RightBrace, SourceRange::default(), vec!['}']));
1468        tkns
1469      },
1470      Subscript::Bracket(subs) => {
1471        let mut tkns = vec![Token::new(TokenKind::LeftBracket, SourceRange::default(), vec!['['])];
1472        for sub in subs {
1473          let mut sub_tkns = sub.tokens();
1474          tkns.append(&mut sub_tkns);
1475        }
1476        tkns.push(Token::new(TokenKind::RightBracket, SourceRange::default(), vec![']']));
1477        tkns
1478      },
1479      Subscript::Dot(id) => id.tokens(),
1480      Subscript::DotInt(num) => num.tokens(),
1481      Subscript::Formula(factor) => factor.tokens(),
1482      Subscript::Range(range) => range.tokens(),
1483      Subscript::Swizzle(ids) => ids.iter().flat_map(|id| id.tokens()).collect(),
1484    }
1485  }
1486}
1487
1488#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1489#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1490pub enum Expression {
1491  Formula(Factor),
1492  FunctionCall(FunctionCall),
1493  //FsmPipe(FsmPipe),
1494  Literal(Literal),
1495  Range(Box<RangeExpression>),
1496  Slice(Slice),
1497  Structure(Structure),
1498  SetComprehension(Box<SetComprehension>),
1499  MatrixComprehension(Box<MatrixComprehension>),
1500  Var(Var),
1501}
1502
1503impl Expression {
1504  pub fn tokens(&self) -> Vec<Token> {
1505    match self {
1506      Expression::Var(v) => v.tokens(),
1507      Expression::Literal(ltrl) => ltrl.tokens(),
1508      Expression::Structure(strct) => strct.tokens(),
1509      Expression::Formula(fctr) => fctr.tokens(),
1510      Expression::Range(range) => range.tokens(),
1511      Expression::Slice(slice) => slice.tokens(),
1512      Expression::SetComprehension(sc) => sc.tokens(),
1513      Expression::MatrixComprehension(mc) => mc.tokens(),
1514      _ => todo!(),
1515    }
1516  }
1517}
1518
1519#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1520#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1521pub struct SetComprehension {
1522  pub expression: Expression,
1523  pub qualifiers: Vec<ComprehensionQualifier>,
1524}
1525
1526impl SetComprehension {
1527  pub fn tokens(&self) -> Vec<Token> {
1528    let mut tokens = self.expression.tokens();
1529    for qualifier in &self.qualifiers {
1530      tokens.append(&mut qualifier.tokens());
1531    }
1532    tokens
1533  }
1534}
1535
1536#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1537#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1538pub struct MatrixComprehension {
1539  pub expression: Expression,
1540  pub qualifiers: Vec<ComprehensionQualifier>,
1541}
1542
1543impl MatrixComprehension {
1544  pub fn tokens(&self) -> Vec<Token> {
1545    let mut tokens = self.expression.tokens();
1546    for qualifier in &self.qualifiers {
1547      tokens.append(&mut qualifier.tokens());
1548    }
1549    tokens
1550  }
1551}
1552
1553#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1554#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1555pub enum ComprehensionQualifier {
1556  Generator((Pattern,Expression)),
1557  Filter(Expression),
1558  Let(VariableDefine),
1559}
1560
1561impl ComprehensionQualifier {
1562  pub fn tokens(&self) -> Vec<Token> {
1563    match self {
1564      ComprehensionQualifier::Generator((pattern, expr)) => {
1565        let mut tokens = pattern.tokens();
1566        tokens.append(&mut expr.tokens());
1567        tokens
1568      }
1569      ComprehensionQualifier::Filter(expr) => expr.tokens(),
1570      ComprehensionQualifier::Let(var_def) => var_def.tokens(),
1571    }
1572  }
1573}
1574
1575pub type ArgumentList = Vec<(Option<Identifier>,Expression)>;
1576
1577#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1578#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1579pub struct FunctionCall {
1580  pub name: Identifier,
1581  pub args: ArgumentList,
1582}
1583
1584impl FunctionCall {
1585  pub fn tokens(&self) -> Vec<Token> {
1586    self.name.tokens()
1587  }
1588}
1589
1590#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1591#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1592pub struct Tuple {
1593  pub elements: Vec<Expression>
1594}
1595
1596impl Tuple {
1597  pub fn tokens(&self) -> Vec<Token> {
1598    let mut tokens = vec![];
1599    for elem in &self.elements {
1600      tokens.append(&mut elem.tokens());
1601    }
1602    tokens
1603  }
1604}
1605
1606#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1607#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1608pub struct Binding {
1609  pub name: Identifier,
1610  pub kind: Option<KindAnnotation>,
1611  pub value: Expression,
1612}
1613
1614impl Binding {
1615  pub fn tokens(&self) -> Vec<Token> {
1616    let mut tokens = self.name.tokens();
1617    if let Some(knd) = &self.kind {
1618      tokens.append(&mut knd.tokens());
1619    }
1620    tokens.append(&mut self.value.tokens());
1621    tokens
1622  }
1623}
1624
1625#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1626#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1627pub struct KindAnnotation {
1628  pub kind: Kind,
1629}
1630
1631impl KindAnnotation {
1632
1633  pub fn hash(&self) -> u64 {
1634    #[cfg(feature = "no_std")]
1635    let mut hasher = FxHasher::default();
1636    #[cfg(not(feature = "no_std"))]
1637    let mut hasher = std::collections::hash_map::DefaultHasher::new();
1638    self.kind.hash(&mut hasher);
1639    hasher.finish()
1640  }
1641
1642  pub fn tokens(&self) -> Vec<Token> {
1643    self.kind.tokens()
1644  }
1645}
1646
1647#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1648#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1649pub enum Kind {
1650  Any,
1651  Atom(Identifier),
1652  Table((Vec<(Identifier,Kind)>,Box<Literal>)),
1653  Set(Box<Kind>,Option<Box<Literal>>),
1654  Record((Vec<(Identifier,Kind)>)),
1655  Empty,
1656  //Fsm(Vec<Kind>,Vec<Kind>),
1657  //Function(Vec<Kind>,Vec<Kind>),
1658  Map(Box<Kind>,Box<Kind>),
1659  Matrix((Box<Kind>,Vec<Literal>)),
1660  Option(Box<Kind>),
1661  Scalar(Identifier),
1662  Tuple(Vec<Kind>),
1663  Kind(Box<Kind>),
1664}
1665
1666impl Kind {
1667  pub fn tokens(&self) -> Vec<Token> {
1668    match self {
1669      Kind::Option(x) => x.tokens(),
1670      Kind::Tuple(x) => x.iter().flat_map(|k| k.tokens()).collect(),
1671      Kind::Matrix((kind, literals)) => {
1672        let mut tokens = kind.tokens();
1673        for l in literals {
1674          tokens.append(&mut l.tokens());
1675        }
1676        tokens
1677      },
1678      Kind::Record(kinds) => {
1679        let mut tokens = vec![];
1680        for (id, kind) in kinds {
1681          tokens.append(&mut id.tokens());
1682          tokens.append(&mut kind.tokens());
1683        }
1684        tokens
1685      }
1686      Kind::Set(kind, size) => {
1687        let mut tokens = kind.tokens();
1688        if let Some(literal) = size {
1689          tokens.append(&mut literal.tokens());
1690        }
1691        tokens
1692      }
1693      Kind::Table((kinds, literal)) => {
1694        let mut tokens = vec![];
1695        for (id, kind) in kinds {
1696          tokens.append(&mut id.tokens());
1697          tokens.append(&mut kind.tokens());
1698        }
1699        tokens.append(&mut literal.tokens());
1700        tokens
1701      }
1702      Kind::Map(x, y) => x.tokens().into_iter().chain(y.tokens()).collect(),
1703      Kind::Scalar(x) => x.tokens(),
1704      Kind::Atom(x) => x.tokens(),
1705      Kind::Kind(x) => x.tokens(),
1706      Kind::Empty => vec![],
1707      Kind::Any => vec![],
1708    }
1709  }
1710}
1711
1712#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1713#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1714pub enum Literal {
1715  Atom(Atom),
1716  Boolean(Token),
1717  Empty(Token),
1718  Number(Number),
1719  String(MechString),
1720  Kind(Kind),
1721  TypedLiteral((Box<Literal>,KindAnnotation))
1722}
1723
1724impl Literal {
1725  pub fn tokens(&self) -> Vec<Token> {
1726    match self {
1727      Literal::Atom(atm) => atm.name.tokens(),
1728      Literal::Boolean(tkn) => vec![tkn.clone()],
1729      Literal::Number(x) => x.tokens(),
1730      Literal::String(strng) => vec![strng.text.clone()],
1731      Literal::Empty(tkn) => vec![tkn.clone()],
1732      Literal::Kind(knd) => knd.tokens(),
1733      Literal::TypedLiteral((lit, knd)) => {
1734        let mut tokens = lit.tokens();
1735        tokens.append(&mut knd.tokens());
1736        tokens
1737      }
1738    }
1739  }
1740}
1741
1742#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1743#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1744pub struct MechString {
1745  pub text: Token,
1746}
1747
1748impl MechString {
1749  pub fn to_string(&self) -> String {
1750    self.text.to_string()
1751  }
1752}
1753
1754pub type Hyperlink = (Paragraph, Token);
1755
1756#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1757#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1758pub enum ParagraphElement {
1759  Emphasis(Box<ParagraphElement>),
1760  FootnoteReference(Token),
1761  Highlight(Box<ParagraphElement>),
1762  Hyperlink(Hyperlink),
1763  InlineCode(Token),
1764  EvalInlineMechCode(Expression),
1765  InlineMechCode(MechCode),
1766  InlineEquation(Token),
1767  Reference(Token),
1768  SectionReference(Token),
1769  Strikethrough(Box<ParagraphElement>),
1770  Strong(Box<ParagraphElement>),
1771  Text(Token),
1772  Underline(Box<ParagraphElement>),
1773  Error(Token, SourceRange),
1774}
1775
1776impl Recoverable for ParagraphElement {
1777  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
1778    ParagraphElement::Error(skipped_tokens, range)
1779  }
1780}
1781
1782impl ParagraphElement {
1783
1784  pub fn tokens(&self) -> Vec<Token> {
1785    match self {
1786      ParagraphElement::Emphasis(t) => t.tokens(),
1787      ParagraphElement::FootnoteReference(t) => vec![t.clone()],
1788      ParagraphElement::Highlight(t) => t.tokens(),
1789      ParagraphElement::Hyperlink((t, u)) => {
1790        let mut tokens = t.tokens();
1791        tokens.push(u.clone());
1792        tokens
1793      },
1794      ParagraphElement::InlineCode(t) => vec![t.clone()],
1795      ParagraphElement::InlineEquation(t) => vec![t.clone()],
1796      ParagraphElement::InlineMechCode(t) => t.tokens(),
1797      ParagraphElement::EvalInlineMechCode(t) => t.tokens(),
1798      ParagraphElement::Reference(t) => vec![t.clone()],
1799      ParagraphElement::SectionReference(t) => vec![t.clone()],
1800      ParagraphElement::Strikethrough(t) => t.tokens(),
1801      ParagraphElement::Strong(t) => t.tokens(),
1802      ParagraphElement::Text(t) => vec![t.clone()],
1803      ParagraphElement::Underline(t) => t.tokens(),
1804      ParagraphElement::Error(t, _) => vec![t.clone()],
1805    }
1806  }
1807
1808  pub fn to_string(&self) -> String {
1809    match self {
1810      ParagraphElement::Emphasis(t) => t.to_string(),
1811      ParagraphElement::FootnoteReference(t) => t.to_string(),
1812      ParagraphElement::Highlight(t) => t.to_string(),
1813      ParagraphElement::Hyperlink((t, u)) => {
1814        format!("[{}]({})", t.to_string(), u.to_string())
1815      }
1816      ParagraphElement::InlineCode(t) => t.to_string(),
1817      ParagraphElement::InlineEquation(t) => t.to_string(),
1818      ParagraphElement::InlineMechCode(t) => format!("{:?}", t),
1819      ParagraphElement::EvalInlineMechCode(t) => format!("{:?}", t),
1820      ParagraphElement::Reference(t) => t.to_string(),
1821      ParagraphElement::SectionReference(t) => t.to_string(),
1822      ParagraphElement::Strikethrough(t) => t.to_string(),
1823      ParagraphElement::Strong(t) => t.to_string(),
1824      ParagraphElement::Text(t) => t.to_string(),
1825      ParagraphElement::Underline(t) => t.to_string(),
1826      ParagraphElement::Error(t, s) => format!("{{ERROR: {} at {:?}}}", t.to_string(), s),
1827    }
1828  }
1829
1830}
1831
1832#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1833#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1834pub struct Paragraph {
1835  pub elements: Vec<ParagraphElement>,
1836  pub error_range: Option<SourceRange>,
1837}
1838
1839impl Paragraph {
1840  pub fn to_string(&self) -> String {
1841    let mut out = "".to_string();
1842    for e in &self.elements {
1843      out.push_str(&e.to_string());
1844    }
1845    out
1846  }
1847
1848  pub fn from_tokens(tokens: Vec<Token>) -> Paragraph {
1849    let elements = tokens.into_iter().map(|t| ParagraphElement::Text(t)).collect();
1850    Paragraph {
1851      elements,
1852      error_range: None,
1853    }
1854  }
1855
1856  pub fn has_errors(&self) -> bool {
1857    self.error_range.is_some()
1858  }
1859
1860  pub fn tokens(&self) -> Vec<Token> {
1861    let mut tkns = vec![];
1862    for e in &self.elements {
1863      let mut e_tkns = e.tokens();
1864      tkns.append(&mut e_tkns);
1865    }
1866    tkns
1867  }
1868
1869}
1870
1871impl Recoverable for Paragraph {
1872  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
1873    Paragraph {
1874      elements: vec![ParagraphElement::Text(Token::new(TokenKind::Error, range.clone(), skipped_tokens.chars.clone()))],
1875      error_range: Some(range),
1876    }
1877  }
1878}
1879
1880
1881pub type Sign = bool;
1882pub type Numerator = Token;
1883pub type Denominator = Token;
1884pub type Whole = Token;
1885pub type Part = Token;
1886pub type Real = Box<Number>;
1887pub type Imaginary = Box<Number>;
1888pub type Base = (Whole, Part);
1889pub type Exponent = (Sign, Whole, Part);
1890
1891#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1892#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1893pub enum Number {
1894  Real(RealNumber),
1895  Complex(C64Node),
1896}
1897
1898impl Number {
1899
1900  pub fn from_integer(x: i64) -> Number {
1901    Number::Real(RealNumber::Integer(Token::new(TokenKind::Digit, SourceRange::default(), x.to_string().chars().collect())))
1902  }
1903
1904  pub fn to_string(&self) -> String {
1905    match self {
1906      Number::Real(x) => x.to_string(),
1907      Number::Complex(x) => x.to_string(),
1908    }
1909  }
1910
1911  pub fn tokens(&self) -> Vec<Token> {
1912    match self {
1913      Number::Real(x) => x.tokens(),
1914      Number::Complex(x) => x.tokens(),
1915    }
1916  }
1917}
1918
1919#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1920#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1921pub enum RealNumber {
1922  Binary(Token),
1923  Decimal(Token),
1924  Float((Whole,Part)),
1925  Hexadecimal(Token),
1926  Integer(Token),
1927  TypedInteger((Token,KindAnnotation)),
1928  Negated(Box<RealNumber>),
1929  Octal(Token),
1930  Rational((Numerator,Denominator)),
1931  Scientific((Base,Exponent)),
1932}
1933
1934impl RealNumber {
1935  pub fn tokens(&self) -> Vec<Token> {
1936    match self {
1937      RealNumber::Integer(tkn) => vec![tkn.clone()],
1938      RealNumber::TypedInteger((tkn, _)) => vec![tkn.clone()],
1939      RealNumber::Float((whole, part)) => vec![whole.clone(), part.clone()],
1940      RealNumber::Binary(tkn) => vec![tkn.clone()],
1941      RealNumber::Hexadecimal(tkn) => vec![tkn.clone()],
1942      RealNumber::Octal(tkn) => vec![tkn.clone()],
1943      RealNumber::Decimal(tkn) => vec![tkn.clone()],
1944      RealNumber::Rational((num, den)) => vec![num.clone(), den.clone()],
1945      RealNumber::Scientific(((whole,part), exponent)) => {
1946        let mut tokens = vec![whole.clone(), part.clone()];
1947        let (sign, whole_exp, part_exp) = exponent;
1948        tokens.push(Token::new(TokenKind::Plus, SourceRange::default(), if *sign { vec!['+'] } else { vec!['-'] }));
1949        tokens.push(whole_exp.clone());
1950        tokens.push(part_exp.clone());
1951        tokens
1952      }
1953      RealNumber::Negated(x) => {
1954        let mut tokens = vec![Token::new(TokenKind::Dash, SourceRange::default(), vec!['-'])];
1955        tokens.append(&mut x.tokens());
1956        tokens
1957      }
1958    }
1959  }
1960  pub fn to_string(&self) -> String {
1961    match self {
1962      RealNumber::Integer(tkn) => tkn.to_string(),
1963      RealNumber::Float((whole, part)) => format!("{}.{}", whole.to_string(), part.to_string()),
1964      RealNumber::Binary(tkn) => format!("0b{}", tkn.to_string()),
1965      RealNumber::Hexadecimal(tkn) => format!("0x{}", tkn.to_string()),
1966      RealNumber::Octal(tkn) => format!("0o{}", tkn.to_string()),
1967      RealNumber::Decimal(tkn) => format!("0d{}", tkn.to_string()),
1968      RealNumber::Rational((num, den)) => format!("{}/{}", num.to_string(), den.to_string()),
1969      RealNumber::Scientific(((whole,part), exponent)) => {
1970        let (sign, whole, part) = exponent;
1971        let sign_str = if *sign { "+" } else { "-" };
1972        let whole_str = whole.to_string();
1973        let part_str = part.to_string();
1974        format!("{}{}.{}/10^{}", whole.to_string(), part.to_string(), sign_str, whole_str)
1975      }
1976      RealNumber::TypedInteger((tkn, kind)) => format!("{}{}", tkn.to_string(), kind.kind.tokens().iter().map(|t| t.to_string()).collect::<String>()),
1977      RealNumber::Negated(x) => format!("-{}", x.to_string()),
1978    }
1979  }
1980}
1981
1982#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1983#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1984pub struct ImaginaryNumber {
1985  pub number: RealNumber,
1986}
1987
1988#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1989#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1990pub struct C64Node {
1991  pub real: Option<RealNumber>,
1992  pub imaginary: ImaginaryNumber
1993}
1994
1995impl C64Node {
1996  pub fn tokens(&self) -> Vec<Token> {
1997    let mut tkns = vec![];
1998    if let Some(r) = &self.real {
1999      tkns.append(&mut r.tokens());
2000    }
2001    tkns.append(&mut self.imaginary.number.tokens());
2002    tkns
2003  }
2004
2005  pub fn to_string(&self) -> String {
2006    let mut out = "".to_string();
2007    if let Some(r) = &self.real {
2008      out.push_str(&r.to_string());
2009    }
2010    out.push_str("i");
2011    out
2012  }
2013}
2014
2015#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2016#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2017pub struct Comment {
2018  pub paragraph: Paragraph,
2019}
2020
2021impl Comment {
2022  pub fn tokens(&self) -> Vec<Token> {
2023    self.paragraph.tokens()
2024  }
2025}
2026
2027#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2028#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2029pub struct OpAssign {
2030  pub target: SliceRef,
2031  pub op: OpAssignOp,
2032  pub expression: Expression,
2033}
2034
2035impl OpAssign {
2036  pub fn tokens(&self) -> Vec<Token> {
2037    let mut tkns = self.target.tokens();
2038    tkns.append(&mut self.op.tokens());
2039    tkns.append(&mut self.expression.tokens());
2040    tkns
2041  }
2042}
2043
2044#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2045#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2046pub enum OpAssignOp {
2047  Add,
2048  Div,
2049  Exp, 
2050  Mod,  
2051  Mul,
2052  Sub,   
2053}
2054
2055impl OpAssignOp {
2056  pub fn tokens(&self) -> Vec<Token> {
2057    match self {
2058      OpAssignOp::Add => vec![Token::new(TokenKind::Plus, SourceRange::default(), vec!['+'])],
2059      OpAssignOp::Div => vec![Token::new(TokenKind::Slash, SourceRange::default(), vec!['/'])],
2060      OpAssignOp::Exp => vec![Token::new(TokenKind::Caret, SourceRange::default(), vec!['^'])],
2061      OpAssignOp::Mod => vec![Token::new(TokenKind::Percent, SourceRange::default(), vec!['%'])],
2062      OpAssignOp::Mul => vec![Token::new(TokenKind::Asterisk, SourceRange::default(), vec!['*'])],
2063      OpAssignOp::Sub => vec![Token::new(TokenKind::Dash, SourceRange::default(), vec!['-'])],
2064    }
2065  }
2066}
2067
2068#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2069#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2070pub enum RangeOp {
2071  Exclusive,      
2072  Inclusive,
2073}
2074
2075#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2076#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2077pub enum AddSubOp {
2078  Add,
2079  Sub,
2080}
2081
2082#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2083#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2084pub enum MulDivOp {
2085  Div,
2086  Mod,
2087  Mul,
2088}
2089
2090#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2091#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2092pub enum VecOp {
2093  Cross,
2094  Dot,
2095  MatMul,
2096  Solve,
2097}
2098
2099#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2100#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2101pub enum PowerOp {
2102  Pow
2103}
2104
2105#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2106#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2107pub enum ComparisonOp {
2108  Equal,
2109  GreaterThan,
2110  GreaterThanEqual,
2111  LessThan,
2112  LessThanEqual,
2113  NotEqual,
2114  StrictEqual,
2115  StrictNotEqual,
2116}
2117
2118#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2119#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2120pub enum LogicOp {
2121  And,
2122  Not,
2123  Or,
2124  Xor,
2125}
2126
2127#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2128#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2129pub enum FormulaOperator {
2130  AddSub(AddSubOp),
2131  Comparison(ComparisonOp),
2132  Power(PowerOp),
2133  Logic(LogicOp),
2134  MulDiv(MulDivOp),
2135  Vec(VecOp),
2136  Table(TableOp),
2137  Set(SetOp),
2138}
2139
2140#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2141#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2142pub enum TableOp {
2143  InnerJoin,
2144  LeftOuterJoin,
2145  RightOuterJoin	,
2146  FullOuterJoin	,
2147  LeftSemiJoin,  
2148  LeftAntiJoin,
2149}
2150
2151#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2152#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2153pub enum SetOp {
2154  Union,
2155  Intersection,
2156  Difference,
2157  Complement,
2158  ElementOf,
2159  NotElementOf,
2160  ProperSubset,
2161  ProperSuperset,
2162  Subset,
2163  Superset,
2164  SymmetricDifference,
2165}
2166
2167#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2168#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2169pub struct RangeExpression {
2170  pub start: Factor,
2171  pub increment: Option<(RangeOp,Factor)>,
2172  pub operator: RangeOp,
2173  pub terminal: Factor,
2174}
2175
2176impl RangeExpression {
2177  pub fn tokens(&self) -> Vec<Token> {
2178    let mut tokens = self.start.tokens();
2179    tokens.append(&mut self.terminal.tokens());
2180    tokens
2181  }
2182}
2183
2184#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2185#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2186pub struct Term {
2187  pub lhs: Factor,
2188  pub rhs: Vec<(FormulaOperator,Factor)>
2189}
2190
2191impl Term {
2192  pub fn tokens(&self) -> Vec<Token> {
2193    let mut lhs_tkns = self.lhs.tokens();
2194    let mut rhs_tkns = vec![];
2195    for (op, r) in &self.rhs {
2196      let mut tkns = r.tokens();
2197      rhs_tkns.append(&mut tkns);
2198    }
2199    lhs_tkns.append(&mut rhs_tkns);
2200    lhs_tkns
2201  }
2202}
2203
2204#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2205#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2206pub enum Factor {
2207  Expression(Box<Expression>),
2208  Negate(Box<Factor>),
2209  Not(Box<Factor>),
2210  Parenthetical(Box<Factor>),
2211  Term(Box<Term>),
2212  Transpose(Box<Factor>),
2213}
2214
2215impl Factor {
2216  pub fn tokens(&self) -> Vec<Token> {
2217    match self {
2218      Factor::Expression(x) => x.tokens(),
2219      Factor::Negate(x) => x.tokens(),
2220      Factor::Not(x) => x.tokens(),
2221      Factor::Parenthetical(x) => x.tokens(),
2222      Factor::Term(x) => x.tokens(),
2223      Factor::Transpose(x) => x.tokens(),
2224    }
2225  }
2226}
mech_core/nodes.rs

mech_core/
nodes.rs
