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  FigureTable(FigureTable),
539  Image(Image),
540  List(MDList),
541  MechCode(Vec<(MechCode,Option<Comment>)>),
542  #[cfg(feature = "mika")]
543  Mika((Mika, Option<MikaSection>)),
544  Paragraph(Paragraph),
545  Subtitle(Subtitle),
546  Table(MarkdownTable),
547  Prompt(Box<SectionElement>),
548  ThematicBreak,
549  Error(Token, SourceRange),
550}
551
552impl Recoverable for SectionElement {
553  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
554    SectionElement::Error(skipped_tokens, range)
555  }
556}
557
558impl SectionElement {
559
560  pub fn tokens(&self) -> Vec<Token> {
561    match self {
562      SectionElement::Prompt(prompt) => prompt.tokens(),
563      #[cfg(feature = "mika")]
564      SectionElement::Mika((mika, mika_section)) => {
565        let mut tokens = vec![];
566        tokens.append(&mut mika.tokens());
567        if let Some(mika_section) = mika_section {
568          for mika_section_element in &mika_section.elements.elements {
569            tokens.append(&mut mika_section_element.tokens());
570          }
571        }
572        tokens
573      },
574      SectionElement::FencedMechCode(c) => {
575        let mut tokens = vec![];
576        for (c, _) in &c.code {
577          tokens.append(&mut c.tokens());
578        }
579        tokens
580      }
581      SectionElement::MechCode(codes) => {
582        let mut tokens = vec![];
583        for (code, _) in codes {
584          tokens.append(&mut code.tokens());
585        }
586        tokens
587      }
588      SectionElement::Abstract(paragraphs)
589      | SectionElement::QuoteBlock(paragraphs)
590      | SectionElement::InfoBlock(paragraphs)
591      | SectionElement::SuccessBlock(paragraphs)
592      | SectionElement::IdeaBlock(paragraphs)
593      | SectionElement::WarningBlock(paragraphs)
594      | SectionElement::ErrorBlock(paragraphs)
595      | SectionElement::QuestionBlock(paragraphs) => {
596        let mut tokens = vec![];
597        for paragraph in paragraphs {
598          tokens.append(&mut paragraph.tokens());
599        }
600        tokens
601      }
602      SectionElement::Citation(citation) => citation.text.tokens(),
603      SectionElement::CodeBlock(token)
604      | SectionElement::Diagram(token)
605      | SectionElement::Equation(token) => vec![token.clone()],
606      SectionElement::Comment(comment) => comment.tokens(),
607      SectionElement::Float((element, _)) => element.tokens(),
608      SectionElement::Footnote((_, paragraphs)) => {
609        let mut tokens = vec![];
610        for paragraph in paragraphs {
611          tokens.append(&mut paragraph.tokens());
612        }
613        tokens
614      }
615        SectionElement::Grammar(grammar) => {
616        let mut tokens = vec![];
617        for rule in &grammar.rules {
618          tokens.append(&mut rule.name.tokens());
619          tokens.append(&mut rule.expr.tokens());
620        }
621        tokens
622      }
623      SectionElement::Image(image) => {
624        let mut tokens = vec![image.src.clone()];
625        if let Some(caption) = &image.caption {
626          tokens.append(&mut caption.tokens());
627        }
628        tokens
629      }
630      SectionElement::FigureTable(figure_table) => {
631        let mut tokens = vec![];
632        for row in &figure_table.rows {
633          for figure in row {
634            tokens.push(figure.src.clone());
635            tokens.append(&mut figure.caption.tokens());
636          }
637        }
638        tokens
639      }
640      SectionElement::List(list) => match list {
641      MDList::Unordered(items) => {
642        let mut tokens = vec![];
643        for ((_, paragraph), sublist) in items {
644        tokens.append(&mut paragraph.tokens());
645        if let Some(sublist) = sublist {
646          tokens.append(&mut sublist.tokens());
647        }
648        }
649        tokens
650      }
651      MDList::Ordered(ordered_list) => {
652        let mut tokens = ordered_list.start.tokens();
653        for ((_, paragraph), sublist) in &ordered_list.items {
654        tokens.append(&mut paragraph.tokens());
655        if let Some(sublist) = sublist {
656          tokens.append(&mut sublist.tokens());
657        }
658        }
659        tokens
660      }
661      MDList::Check(items) => {
662        let mut tokens = vec![];
663        for ((_, paragraph), sublist) in items {
664        tokens.append(&mut paragraph.tokens());
665        if let Some(sublist) = sublist {
666          tokens.append(&mut sublist.tokens());
667        }
668        }
669        tokens
670      }
671      },
672      SectionElement::Paragraph(paragraph) => paragraph.tokens(),
673      SectionElement::Subtitle(subtitle) => subtitle.text.tokens(),
674      SectionElement::Table(table) => {
675        let mut tokens = vec![];
676        for header in &table.header {
677          tokens.append(&mut header.tokens());
678        }
679        for row in &table.rows {
680          for column in row {
681          tokens.append(&mut column.tokens());
682          }
683        }
684        tokens
685      }
686      SectionElement::ThematicBreak => vec![],
687      SectionElement::Error(token, _) => vec![token.clone()],
688    }
689  }
690}
691
692
693#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
694#[derive(Clone, Debug, Hash, PartialEq, Eq)]
695pub struct OptionMap {
696  pub elements: Vec<(Identifier, MechString)>,
697}
698
699
700#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
701#[derive(Clone, Debug, Hash, PartialEq, Eq)]
702pub struct Image {
703  pub src: Token,
704  pub caption: Option<Paragraph>,
705  pub style: Option<OptionMap>,
706}
707
708impl Image {
709  pub fn to_string(&self) -> String {
710    let caption = match &self.caption {
711      Some(c) => c.to_string(),
712      None => "".to_string(),
713    };
714    format!("![{}]({})", caption, self.src.to_string())
715  }
716}
717
718#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
719#[derive(Clone, Debug, Hash, PartialEq, Eq)]
720pub struct FigureItem {
721  pub src: Token,
722  pub caption: Paragraph,
723}
724
725#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
726#[derive(Clone, Debug, Hash, PartialEq, Eq)]
727pub struct FigureTable {
728  pub rows: Vec<Vec<FigureItem>>,
729}
730
731pub type UnorderedList = Vec<((Option<Token>,Paragraph),Option<MDList>)>;
732pub type CheckList = Vec<((bool,Paragraph),Option<MDList>)>;
733
734#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
735#[derive(Clone, Debug, Hash, PartialEq, Eq)]
736pub struct OrderedList {
737  pub start: Number,
738  pub items: Vec<((Number,Paragraph),Option<MDList>)>,
739}
740
741#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
742#[derive(Clone, Debug, Hash, PartialEq, Eq)]
743pub enum MDList {
744  Unordered(UnorderedList),
745  Ordered(OrderedList),
746  Check(CheckList)
747}
748
749impl MDList {
750
751  pub fn tokens(&self) -> Vec<Token> {
752    match self {
753      MDList::Unordered(items) => {
754        let mut tokens = vec![];
755        for ((_, paragraph), sublist) in items {
756          tokens.append(&mut paragraph.tokens());
757          if let Some(sublist) = sublist {
758            tokens.append(&mut sublist.tokens());
759          }
760        }
761        tokens
762      }
763      MDList::Ordered(ordered_list) => {
764        let mut tokens = ordered_list.start.tokens();
765        for ((_, paragraph), sublist) in &ordered_list.items {
766          tokens.append(&mut paragraph.tokens());
767          if let Some(sublist) = sublist {
768            tokens.append(&mut sublist.tokens());
769          }
770        }
771        tokens
772      }
773      MDList::Check(items) => {
774        let mut tokens = vec![];
775        for ((_, paragraph), sublist) in items {
776          tokens.append(&mut paragraph.tokens());
777          if let Some(sublist) = sublist {
778            tokens.append(&mut sublist.tokens());
779          }
780        }
781        tokens
782      }
783    }
784  }
785
786}
787
788#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
789#[derive(Clone, Debug, Hash, PartialEq, Eq)]
790pub enum MechCode {
791  Comment(Comment),
792  Expression(Expression),
793  FsmImplementation(FsmImplementation),
794  FsmSpecification(FsmSpecification),
795  FunctionDefine(FunctionDefine),
796  Statement(Statement),
797  Error(Token, SourceRange),
798}
799
800impl Recoverable for MechCode {
801  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
802    MechCode::Error(skipped_tokens, range)
803  }
804}
805
806impl MechCode {
807  pub fn tokens(&self) -> Vec<Token> {
808    match self {
809      MechCode::Expression(x) => x.tokens(),
810      MechCode::Statement(x) => x.tokens(),
811      MechCode::Comment(x) => x.tokens(),
812      MechCode::FsmSpecification(x) => x.tokens(),
813      MechCode::FsmImplementation(x) => x.tokens(),
814      MechCode::FunctionDefine(_) => vec![],
815      MechCode::Error(t,_) => vec![t.clone()],
816    }
817  }
818}
819
820#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
821#[derive(Clone, Debug, Hash, PartialEq, Eq)]
822pub struct FunctionDefine {
823  pub name: Identifier,
824  pub input: Vec<FunctionArgument>,
825  pub output: Vec<FunctionArgument>,
826  pub statements: Vec<Statement>,
827  pub match_arms: Vec<FunctionMatchArm>,
828}
829
830#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
831#[derive(Clone, Debug, Hash, PartialEq, Eq)]
832pub struct FunctionMatchArm {
833  pub pattern: Pattern,
834  pub expression: Expression,
835}
836
837#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
838#[derive(Clone, Debug, Hash, PartialEq, Eq)]
839pub struct MatchArm {
840  pub pattern: Pattern,
841  pub guard: Option<Expression>,
842  pub expression: Expression,
843}
844
845#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
846#[derive(Clone, Debug, Hash, PartialEq, Eq)]
847pub struct FunctionArgument {
848  pub name: Identifier,
849  pub kind: KindAnnotation,
850}
851
852impl FunctionArgument {
853  pub fn tokens(&self) -> Vec<Token> {
854    let mut tokens = self.name.tokens();
855    tokens.append(&mut self.kind.tokens());
856    tokens
857  }
858}
859
860#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
861#[derive(Clone, Debug, Hash, PartialEq, Eq)]
862pub struct FsmImplementation {
863  pub name: Identifier,
864  pub input: Vec<Var>,
865  pub start: Pattern,
866  pub arms: Vec<FsmArm>,
867}
868
869impl FsmImplementation {
870  pub fn tokens(&self) -> Vec<Token> {
871    let mut tokens = self.name.tokens();
872    for input in &self.input {
873      tokens.append(&mut input.tokens());
874    }
875    tokens.append(&mut self.start.tokens());
876    for arm in &self.arms {
877      tokens.append(&mut arm.tokens());
878    }
879    tokens
880  }
881}
882
883#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
884#[derive(Clone, Debug, Hash, PartialEq, Eq)]
885pub enum FsmArm {
886  Guard(Pattern,Vec<Guard>),
887  Transition(Pattern,Vec<Transition>),
888  Comment(Comment),
889}
890
891impl FsmArm {
892  pub fn tokens(&self) -> Vec<Token> {
893    match self {
894      FsmArm::Guard(pattern, guards) => {
895        let mut tokens = pattern.tokens();
896        for guard in guards {
897          tokens.append(&mut guard.tokens());
898        }
899        tokens
900      }
901      FsmArm::Transition(pattern, transitions) => {
902        let mut tokens = pattern.tokens();
903        for transition in transitions {
904          tokens.append(&mut transition.tokens());
905        }
906        tokens
907      }
908      FsmArm::Comment(comment) => comment.tokens(),
909    }
910  }
911}
912
913#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
914#[derive(Clone, Debug, Hash, PartialEq, Eq)]
915pub struct Guard { 
916  pub condition: Pattern,
917  pub transitions: Vec<Transition>,
918}
919
920impl Guard {
921  pub fn tokens(&self) -> Vec<Token> {
922    let mut tokens = self.condition.tokens();
923    for transition in &self.transitions {
924      tokens.append(&mut transition.tokens());
925    }
926    tokens
927  }
928}
929
930#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
931#[derive(Clone, Debug, Hash, PartialEq, Eq)]
932pub enum Transition {
933  Async(Pattern),
934  CodeBlock(Vec<(MechCode, Option<Comment>)>),
935  Next(Pattern),
936  Output(Pattern),
937  Statement(Statement),
938}
939
940impl Transition {
941  pub fn tokens(&self) -> Vec<Token> {
942    match self {
943      Transition::Async(pattern) => pattern.tokens(),
944      Transition::CodeBlock(code) => code.iter().flat_map(|(mech_code, comment)| {
945        let mut tokens = mech_code.tokens();
946        if let Some(comment) = comment {
947          tokens.append(&mut comment.tokens());
948        }
949        tokens
950      }).collect(),
951      Transition::Next(pattern) => pattern.tokens(),
952      Transition::Output(pattern) => pattern.tokens(),
953      Transition::Statement(statement) => statement.tokens(),
954    }
955  }
956}
957
958#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
959#[derive(Clone, Debug, Hash, PartialEq, Eq)]
960pub enum Pattern {
961  Expression(Expression),
962  TupleStruct(PatternTupleStruct),
963  Tuple(PatternTuple),
964  Array(PatternArray),
965  Wildcard,
966}
967
968impl Pattern {
969  pub fn tokens(&self) -> Vec<Token> {
970    match self {
971      Pattern::Expression(e) => e.tokens(),
972      Pattern::TupleStruct(ts) => ts.tokens(),
973      Pattern::Tuple(t) => t.tokens(),
974      Pattern::Array(a) => a.tokens(),
975      Pattern::Wildcard => vec![],
976    }
977  }
978}
979
980#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
981#[derive(Clone, Debug, Hash, PartialEq, Eq)]
982pub struct PatternArray {
983  pub prefix: Vec<Pattern>,
984  pub spread: Option<PatternArraySpread>,
985  pub suffix: Vec<Pattern>,
986}
987
988impl PatternArray {
989  pub fn tokens(&self) -> Vec<Token> {
990    let mut tokens = vec![];
991    for p in &self.prefix {
992      tokens.append(&mut p.tokens());
993    }
994    if let Some(spread) = &self.spread {
995      if let Some(binding) = &spread.binding {
996        tokens.append(&mut binding.tokens());
997      }
998    }
999    for p in &self.suffix {
1000      tokens.append(&mut p.tokens());
1001    }
1002    tokens
1003  }
1004}
1005
1006#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1007#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1008pub struct PatternArraySpread {
1009  pub binding: Option<Box<Pattern>>,
1010}
1011
1012#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1013#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1014pub struct PatternTupleStruct {
1015  pub name: Identifier,
1016  pub patterns: Vec<Pattern>,
1017}
1018
1019impl PatternTupleStruct {
1020  pub fn tokens(&self) -> Vec<Token> {
1021    let mut tokens = self.name.tokens();
1022    for p in &self.patterns {
1023      tokens.append(&mut p.tokens());
1024    }
1025    tokens
1026  }
1027}
1028
1029#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1030#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1031pub struct PatternTuple(pub Vec<Pattern>);
1032
1033impl PatternTuple {
1034  pub fn tokens(&self) -> Vec<Token> {
1035    let mut tokens = vec![];
1036    for p in &self.0 {
1037        tokens.append(&mut p.tokens());
1038    }
1039    tokens
1040  }
1041}
1042
1043#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1044#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1045pub struct FsmSpecification {
1046  pub name: Identifier,
1047  pub input: Vec<Var>,
1048  pub output: Option<KindAnnotation>,
1049  pub states: Vec<StateDefinition>,
1050}
1051
1052impl FsmSpecification {
1053  pub fn tokens(&self) -> Vec<Token> {
1054    let mut tokens = self.name.tokens();
1055    for var in &self.input {
1056      tokens.append(&mut var.tokens());
1057    }
1058    if let Some(output) = &self.output {
1059      tokens.append(&mut output.tokens());
1060    }
1061    for state in &self.states {
1062      tokens.append(&mut state.tokens());
1063    }
1064    tokens
1065  }
1066}
1067
1068#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1069#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1070pub struct StateDefinition {
1071  pub name: Identifier,
1072  pub state_variables: Option<Vec<Var>>,
1073}
1074
1075impl StateDefinition {
1076  pub fn tokens(&self) -> Vec<Token> {
1077    let mut tokens = self.name.tokens();
1078    if let Some(vars) = &self.state_variables {
1079      for var in vars {
1080        tokens.append(&mut var.tokens());
1081      }
1082    }
1083    tokens
1084  }
1085}
1086
1087#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1088#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1089pub enum Statement {
1090  EnumDefine(EnumDefine),
1091  FsmDeclare(FsmDeclare),
1092  KindDefine(KindDefine),
1093  OpAssign(OpAssign),
1094  VariableAssign(VariableAssign),
1095  VariableDefine(VariableDefine),
1096  TupleDestructure(TupleDestructure),
1097  SplitTable,     // todo
1098  FlattenTable,   // todo
1099}
1100
1101impl Statement {
1102  pub fn tokens(&self) -> Vec<Token> {
1103    match self {
1104      Statement::EnumDefine(x) => x.tokens(),
1105      Statement::FsmDeclare(x) => x.tokens(),
1106      Statement::KindDefine(x) => x.tokens(),
1107      Statement::OpAssign(x) => x.tokens(),
1108      Statement::VariableAssign(x) => x.tokens(),
1109      Statement::VariableDefine(x) => x.tokens(),
1110      Statement::TupleDestructure(x) => x.tokens(),
1111      Statement::SplitTable => vec![], // todo
1112      Statement::FlattenTable => vec![], // todo
1113    }
1114  }
1115}
1116
1117#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1118#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1119pub struct TupleDestructure {
1120  pub vars: Vec<Identifier>,
1121  pub expression: Expression,
1122}
1123
1124impl TupleDestructure {
1125  pub fn tokens(&self) -> Vec<Token> {
1126    let mut tokens = vec![];
1127    for var in &self.vars {
1128      tokens.append(&mut var.tokens());
1129    }
1130    tokens.append(&mut self.expression.tokens());
1131    tokens
1132  }
1133}
1134
1135#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1136#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1137pub struct FsmPipe {
1138  pub start: FsmInstance,
1139  pub transitions: Vec<Transition>
1140}
1141
1142impl FsmPipe {
1143  pub fn tokens(&self) -> Vec<Token> {
1144    let mut tokens = self.start.tokens();
1145    for transition in &self.transitions {
1146      tokens.append(&mut transition.tokens());
1147    }
1148    tokens
1149  }
1150}
1151
1152#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1153#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1154pub enum PipeElement {
1155  Expression(Expression),
1156  FsmInstance(FsmInstance),
1157  Timer // todo
1158}
1159
1160#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1161#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1162pub struct FsmDeclare {
1163  pub fsm: Fsm,
1164  pub pipe: FsmPipe,
1165}
1166
1167impl FsmDeclare {
1168  pub fn tokens(&self) -> Vec<Token> {
1169    let mut tokens = self.fsm.tokens();
1170    tokens.append(&mut self.pipe.tokens());
1171    tokens
1172  }
1173}
1174
1175#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1176#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1177pub struct Fsm {
1178  pub name: Identifier,
1179  pub args: Option<ArgumentList>,
1180  pub kind: Option<KindAnnotation>
1181}
1182
1183impl Fsm {
1184  pub fn tokens(&self) -> Vec<Token> {
1185    let mut tokens = self.name.tokens();
1186    if let Some(args) = &self.args {
1187      for (binding, expression) in args {
1188        if let Some(binding) = binding {
1189          tokens.append(&mut binding.tokens());
1190        }
1191        tokens.append(&mut expression.tokens());
1192      }
1193    }
1194    if let Some(kind) = &self.kind {
1195      tokens.append(&mut kind.tokens());
1196    }
1197    tokens
1198  }
1199}
1200
1201pub type FsmArgs = Vec<(Option<Identifier>,Expression)>;
1202
1203#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1204#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1205pub struct FsmInstance {
1206  pub name: Identifier,
1207  pub args: Option<FsmArgs>,
1208}
1209
1210impl FsmInstance {
1211  pub fn tokens(&self) -> Vec<Token> {
1212    let mut tokens = self.name.tokens();
1213    if let Some(args) = &self.args {
1214      for (binding, expression) in args {
1215        if let Some(binding) = binding {
1216          tokens.append(&mut binding.tokens());
1217        }
1218        tokens.append(&mut expression.tokens());
1219      }
1220    }
1221    tokens
1222  }
1223}
1224
1225#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1226#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1227pub struct EnumDefine {
1228  pub name: Identifier,
1229  pub variants: Vec<EnumVariant>,
1230}
1231
1232impl EnumDefine {
1233  pub fn tokens(&self) -> Vec<Token> {
1234    let mut tokens = self.name.tokens();
1235    for v in &self.variants {
1236      tokens.append(&mut v.tokens());
1237    }
1238    tokens
1239  }
1240}
1241
1242#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1243#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1244pub struct EnumVariant {
1245  pub name: Identifier,
1246  pub value: Option<KindAnnotation>,
1247}
1248
1249impl EnumVariant {
1250  pub fn tokens(&self) -> Vec<Token> {
1251    let mut tokens = self.name.tokens();
1252    if let Some(value) = &self.value {
1253      tokens.append(&mut value.tokens());
1254    }
1255    tokens
1256  }
1257}
1258
1259#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1260#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1261pub struct KindDefine {
1262  pub name: Identifier,
1263  pub kind: KindAnnotation,
1264}
1265
1266impl KindDefine {
1267  pub fn tokens(&self) -> Vec<Token> {
1268    let mut tokens = self.name.tokens();
1269    tokens.append(&mut self.kind.tokens());
1270    tokens
1271  }
1272}
1273
1274#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1275#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1276pub struct Record {
1277  pub bindings: Vec<Binding>,
1278}
1279
1280impl Record {
1281  pub fn tokens(&self) -> Vec<Token> {
1282    let mut tkns = vec![];
1283    for b in &self.bindings {
1284      let mut t = b.tokens();
1285      tkns.append(&mut t);
1286    }
1287    tkns
1288  }
1289}
1290
1291#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1292#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1293pub enum Structure {
1294  Empty,
1295  Map(Map),
1296  Matrix(Matrix),
1297  Record(Record),
1298  Set(Set),
1299  Table(Table),
1300  Tuple(Tuple),
1301  TupleStruct(TupleStruct),
1302}
1303
1304impl Structure {
1305  pub fn tokens(&self) -> Vec<Token> {
1306    match self {
1307      Structure::Empty => vec![],
1308      Structure::Map(map) => map.tokens(),
1309      Structure::Matrix(mat) => mat.tokens(),
1310      Structure::Record(rec) => rec.tokens(),
1311      Structure::Set(set) => set.tokens(),
1312      Structure::Table(tab) => tab.tokens(),
1313      Structure::Tuple(tup) => tup.tokens(),
1314      Structure::TupleStruct(ts) => ts.tokens(),
1315    }
1316  }
1317}
1318
1319#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1320#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1321pub struct Map {
1322  pub elements: Vec<Mapping>,
1323}
1324
1325impl Map {
1326  pub fn tokens(&self) -> Vec<Token> {
1327    let mut tkns = vec![];
1328    for e in &self.elements {
1329      let mut t = e.tokens();
1330      tkns.append(&mut t);
1331    }
1332    tkns
1333  }
1334}
1335
1336#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1337#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1338pub struct Mapping {
1339  pub key: Expression,
1340  pub value: Expression,
1341}
1342
1343impl Mapping {
1344  pub fn tokens(&self) -> Vec<Token> {
1345    let mut tkns = self.key.tokens();
1346    tkns.append(&mut self.value.tokens());
1347    tkns
1348  }
1349}
1350
1351#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1352#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1353pub struct Set {
1354  pub elements: Vec<Expression>,
1355}
1356
1357impl Set {
1358  pub fn tokens(&self) -> Vec<Token> {
1359    let mut tkns = vec![];
1360    for e in &self.elements {
1361      let mut t = e.tokens();
1362      tkns.append(&mut t);
1363    }
1364    tkns
1365  }
1366}
1367
1368#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1369#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1370pub struct Atom {
1371  pub name: Identifier,
1372}
1373
1374impl Atom {
1375  pub fn tokens(&self) -> Vec<Token> {
1376    self.name.tokens()
1377  }
1378}
1379
1380#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1381#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1382pub struct TupleStruct {
1383  pub name: Identifier,
1384  pub value: Box<Expression>,
1385}
1386
1387impl TupleStruct {
1388  pub fn tokens(&self) -> Vec<Token> {
1389    let mut tkns = self.name.tokens();
1390    tkns.append(&mut self.value.tokens());
1391    tkns
1392  }
1393}
1394
1395#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1396#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1397pub struct Matrix {
1398  pub rows: Vec<MatrixRow>,
1399}
1400
1401impl Matrix {
1402  pub fn tokens(&self) -> Vec<Token> {
1403    let mut tkns = vec![];
1404    for r in &self.rows {
1405      let mut t = r.tokens();
1406      tkns.append(&mut t);
1407    }
1408    tkns
1409  }
1410}
1411
1412#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1413#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1414pub struct TableHeader(pub Vec<Field>);
1415
1416impl TableHeader {
1417  pub fn new(fields: Vec<Field>) -> TableHeader {
1418    TableHeader(fields)
1419  }
1420  pub fn tokens(&self) -> Vec<Token> {
1421    let mut tkns = vec![];
1422    for f in &self.0 {
1423      let mut t = f.tokens();
1424      tkns.append(&mut t);
1425    }
1426    tkns
1427  }
1428}
1429
1430#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1431#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1432pub struct Table {
1433  pub header: TableHeader,
1434  pub rows: Vec<TableRow>,
1435}
1436
1437impl Table {
1438  pub fn tokens(&self) -> Vec<Token> {
1439    let mut tkns = vec![];
1440    for f in &self.header.0 {
1441      let mut t = f.tokens();
1442      tkns.append(&mut t);
1443    }
1444    for r in &self.rows {
1445      let mut t = r.tokens();
1446      tkns.append(&mut t);
1447    }
1448    tkns
1449  }
1450}
1451
1452#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1453#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1454pub struct Field {
1455  pub name: Identifier,
1456  pub kind: Option<KindAnnotation>,
1457}
1458
1459impl Field {
1460  pub fn tokens(&self) -> Vec<Token> {
1461    let mut tkns = self.name.tokens();
1462    if let Some(knd) = &self.kind {
1463      let mut t = knd.tokens();
1464      tkns.append(&mut t);
1465    }
1466    tkns
1467  }
1468}
1469
1470#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1471#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1472pub struct TableColumn {
1473  pub element: Expression,
1474}
1475
1476impl TableColumn {
1477  pub fn tokens(&self) -> Vec<Token> {
1478    self.element.tokens()
1479  }
1480}
1481
1482#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1483#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1484pub struct MatrixColumn {
1485  pub element: Expression,
1486}
1487
1488impl MatrixColumn {
1489  pub fn tokens(&self) -> Vec<Token> {
1490    self.element.tokens()
1491  }
1492}
1493
1494#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1495#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1496pub struct TableRow {
1497  pub columns: Vec<TableColumn>,
1498}
1499
1500impl TableRow {
1501  pub fn tokens(&self) -> Vec<Token> {
1502    let mut tkns = vec![];
1503    for r in &self.columns {
1504      let mut t = r.element.tokens();
1505      tkns.append(&mut t);
1506    }
1507    tkns
1508  }
1509}
1510
1511#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1512#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1513pub struct MatrixRow {
1514  pub columns: Vec<MatrixColumn>,
1515}
1516
1517impl MatrixRow {
1518  pub fn tokens(&self) -> Vec<Token> {
1519    let mut tkns = vec![];
1520    for r in &self.columns {
1521      let mut t = r.tokens();
1522      tkns.append(&mut t);
1523    }
1524    tkns
1525  }
1526}
1527
1528#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1529#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1530pub struct VariableDefine {
1531  pub mutable: bool,
1532  pub var: Var,
1533  pub expression: Expression,
1534}
1535
1536impl VariableDefine {
1537  pub fn tokens(&self) -> Vec<Token> {
1538    let mut tkns = self.var.tokens();
1539    tkns.append(&mut self.expression.tokens());
1540    tkns
1541  }
1542}
1543
1544#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1545#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1546pub struct Var {
1547  pub name: Identifier,
1548  pub kind: Option<KindAnnotation>,
1549}
1550
1551impl Var {
1552  pub fn tokens(&self) -> Vec<Token> {
1553    let mut tkns = self.name.tokens();
1554    if let Some(knd) = &self.kind {
1555      let mut t = knd.tokens();
1556      tkns.append(&mut t);
1557    }
1558    tkns
1559  }
1560}
1561
1562#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1563#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1564pub struct VariableAssign {
1565  pub target: SliceRef,
1566  pub expression: Expression,
1567}
1568
1569impl VariableAssign {
1570  pub fn tokens(&self) -> Vec<Token> {
1571    let mut tkns = self.target.tokens();
1572    tkns.append(&mut self.expression.tokens());
1573    tkns
1574  }
1575}
1576
1577#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1578#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1579pub struct Identifier {
1580  pub name: Token,
1581}
1582
1583impl Identifier {
1584  pub fn tokens(&self) -> Vec<Token> {
1585    vec![self.name.clone()]
1586  }
1587
1588  pub fn to_string(&self) -> String {
1589    self.name.to_string()
1590  }
1591
1592}
1593
1594impl Identifier {
1595  pub fn hash(&self) -> u64 {
1596    hash_chars(&self.name.chars)
1597  }
1598}
1599
1600#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1601#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1602pub struct Emoji {
1603  pub tokens: Vec<Token>,
1604}
1605
1606#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1607#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1608pub struct Word {
1609  pub tokens: Vec<Token>,
1610}
1611
1612#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1613#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1614pub struct Slice {
1615  pub name: Identifier,
1616  pub subscript: Vec<Subscript>
1617}
1618
1619impl Slice {
1620  pub fn tokens(&self) -> Vec<Token> {
1621    let mut tkns = self.name.tokens();
1622    for sub in &self.subscript {
1623      let mut sub_tkns = sub.tokens();
1624      tkns.append(&mut sub_tkns);
1625    }
1626    tkns
1627  }
1628}
1629
1630#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1631#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1632pub struct SliceRef {
1633  pub name: Identifier,
1634  pub subscript: Option<Vec<Subscript>>
1635}
1636
1637impl SliceRef {
1638  pub fn tokens(&self) -> Vec<Token> {
1639    let mut tkns = self.name.tokens();
1640    if let Some(subs) = &self.subscript {
1641      for sub in subs {
1642        let mut sub_tkns = sub.tokens();
1643        tkns.append(&mut sub_tkns);
1644      }
1645    }
1646    tkns
1647  }
1648}
1649
1650#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1651#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1652pub enum Subscript {
1653  All,                      // a[:]
1654  Brace(Vec<Subscript>),    // a{"foo"}
1655  Bracket(Vec<Subscript>),  // a[1,2,3]
1656  Dot(Identifier),          // a.b
1657  DotInt(RealNumber),       // a.1
1658  Formula(Factor),          // a[1 + 1]
1659  Range(RangeExpression),   // a[1 + 1]
1660  Swizzle(Vec<Identifier>), // a.b,c
1661}
1662
1663impl Subscript {
1664
1665  pub fn tokens(&self) -> Vec<Token> {
1666    match self {
1667      Subscript::All => vec![
1668        Token::new(TokenKind::Colon, SourceRange::default(), vec![':']),
1669      ],
1670      Subscript::Brace(subs) => {
1671        let mut tkns = vec![Token::new(TokenKind::LeftBrace, SourceRange::default(), vec!['{'])];
1672        for sub in subs {
1673          let mut sub_tkns = sub.tokens();
1674          tkns.append(&mut sub_tkns);
1675        }
1676        tkns.push(Token::new(TokenKind::RightBrace, SourceRange::default(), vec!['}']));
1677        tkns
1678      },
1679      Subscript::Bracket(subs) => {
1680        let mut tkns = vec![Token::new(TokenKind::LeftBracket, SourceRange::default(), vec!['['])];
1681        for sub in subs {
1682          let mut sub_tkns = sub.tokens();
1683          tkns.append(&mut sub_tkns);
1684        }
1685        tkns.push(Token::new(TokenKind::RightBracket, SourceRange::default(), vec![']']));
1686        tkns
1687      },
1688      Subscript::Dot(id) => id.tokens(),
1689      Subscript::DotInt(num) => num.tokens(),
1690      Subscript::Formula(factor) => factor.tokens(),
1691      Subscript::Range(range) => range.tokens(),
1692      Subscript::Swizzle(ids) => ids.iter().flat_map(|id| id.tokens()).collect(),
1693    }
1694  }
1695}
1696
1697#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1698#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1699pub enum Expression {
1700  Formula(Factor),
1701  FunctionCall(FunctionCall),
1702  FsmPipe(FsmPipe),
1703  Literal(Literal),
1704  Match(Box<MatchExpression>),
1705  Range(Box<RangeExpression>),
1706  Slice(Slice),
1707  Structure(Structure),
1708  SetComprehension(Box<SetComprehension>),
1709  MatrixComprehension(Box<MatrixComprehension>),
1710  Var(Var),
1711}
1712
1713impl Expression {
1714  pub fn tokens(&self) -> Vec<Token> {
1715    match self {
1716      Expression::Var(v) => v.tokens(),
1717      Expression::Literal(ltrl) => ltrl.tokens(),
1718      Expression::Structure(strct) => strct.tokens(),
1719      Expression::Formula(fctr) => fctr.tokens(),
1720      Expression::Match(match_expr) => match_expr.tokens(),
1721      Expression::Range(range) => range.tokens(),
1722      Expression::Slice(slice) => slice.tokens(),
1723      Expression::SetComprehension(sc) => sc.tokens(),
1724      Expression::FsmPipe(pipe) => pipe.tokens(),
1725      Expression::MatrixComprehension(mc) => mc.tokens(),
1726      _ => todo!(),
1727    }
1728  }
1729}
1730
1731#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1732#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1733pub struct MatchExpression {
1734  pub source: Expression,
1735  pub arms: Vec<MatchArm>,
1736}
1737
1738impl MatchExpression {
1739  pub fn tokens(&self) -> Vec<Token> {
1740    let mut tokens = self.source.tokens();
1741    for arm in &self.arms {
1742      tokens.append(&mut arm.pattern.tokens());
1743      if let Some(guard) = &arm.guard {
1744        tokens.append(&mut guard.tokens());
1745      }
1746      tokens.append(&mut arm.expression.tokens());
1747    }
1748    tokens
1749  }
1750}
1751
1752#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1753#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1754pub struct SetComprehension {
1755  pub expression: Expression,
1756  pub qualifiers: Vec<ComprehensionQualifier>,
1757}
1758
1759impl SetComprehension {
1760  pub fn tokens(&self) -> Vec<Token> {
1761    let mut tokens = self.expression.tokens();
1762    for qualifier in &self.qualifiers {
1763      tokens.append(&mut qualifier.tokens());
1764    }
1765    tokens
1766  }
1767}
1768
1769#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1770#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1771pub struct MatrixComprehension {
1772  pub expression: Expression,
1773  pub qualifiers: Vec<ComprehensionQualifier>,
1774}
1775
1776impl MatrixComprehension {
1777  pub fn tokens(&self) -> Vec<Token> {
1778    let mut tokens = self.expression.tokens();
1779    for qualifier in &self.qualifiers {
1780      tokens.append(&mut qualifier.tokens());
1781    }
1782    tokens
1783  }
1784}
1785
1786#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1787#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1788pub enum ComprehensionQualifier {
1789  Generator((Pattern,Expression)),
1790  Filter(Expression),
1791  Let(VariableDefine),
1792}
1793
1794impl ComprehensionQualifier {
1795  pub fn tokens(&self) -> Vec<Token> {
1796    match self {
1797      ComprehensionQualifier::Generator((pattern, expr)) => {
1798        let mut tokens = pattern.tokens();
1799        tokens.append(&mut expr.tokens());
1800        tokens
1801      }
1802      ComprehensionQualifier::Filter(expr) => expr.tokens(),
1803      ComprehensionQualifier::Let(var_def) => var_def.tokens(),
1804    }
1805  }
1806}
1807
1808pub type ArgumentList = Vec<(Option<Identifier>,Expression)>;
1809
1810#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1811#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1812pub struct FunctionCall {
1813  pub name: Identifier,
1814  pub args: ArgumentList,
1815}
1816
1817impl FunctionCall {
1818  pub fn tokens(&self) -> Vec<Token> {
1819    self.name.tokens()
1820  }
1821}
1822
1823#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1824#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1825pub struct Tuple {
1826  pub elements: Vec<Expression>
1827}
1828
1829impl Tuple {
1830  pub fn tokens(&self) -> Vec<Token> {
1831    let mut tokens = vec![];
1832    for elem in &self.elements {
1833      tokens.append(&mut elem.tokens());
1834    }
1835    tokens
1836  }
1837}
1838
1839#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1840#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1841pub struct Binding {
1842  pub name: Identifier,
1843  pub kind: Option<KindAnnotation>,
1844  pub value: Expression,
1845}
1846
1847impl Binding {
1848  pub fn tokens(&self) -> Vec<Token> {
1849    let mut tokens = self.name.tokens();
1850    if let Some(knd) = &self.kind {
1851      tokens.append(&mut knd.tokens());
1852    }
1853    tokens.append(&mut self.value.tokens());
1854    tokens
1855  }
1856}
1857
1858#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1859#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1860pub struct KindAnnotation {
1861  pub kind: Kind,
1862}
1863
1864impl KindAnnotation {
1865
1866  pub fn hash(&self) -> u64 {
1867    #[cfg(feature = "no_std")]
1868    let mut hasher = FxHasher::default();
1869    #[cfg(not(feature = "no_std"))]
1870    let mut hasher = std::collections::hash_map::DefaultHasher::new();
1871    self.kind.hash(&mut hasher);
1872    hasher.finish()
1873  }
1874
1875  pub fn tokens(&self) -> Vec<Token> {
1876    self.kind.tokens()
1877  }
1878}
1879
1880#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1881#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1882pub enum Kind {
1883  Any,
1884  Atom(Identifier),
1885  Table((Vec<(Identifier,Kind)>,Box<Literal>)),
1886  Set(Box<Kind>,Option<Box<Literal>>),
1887  Record((Vec<(Identifier,Kind)>)),
1888  Empty,
1889  //Fsm(Vec<Kind>,Vec<Kind>),
1890  //Function(Vec<Kind>,Vec<Kind>),
1891  Map(Box<Kind>,Box<Kind>),
1892  Matrix((Box<Kind>,Vec<Literal>)),
1893  Option(Box<Kind>),
1894  Scalar(Identifier),
1895  Tuple(Vec<Kind>),
1896  Kind(Box<Kind>),
1897}
1898
1899impl Kind {
1900  pub fn tokens(&self) -> Vec<Token> {
1901    match self {
1902      Kind::Option(x) => x.tokens(),
1903      Kind::Tuple(x) => x.iter().flat_map(|k| k.tokens()).collect(),
1904      Kind::Matrix((kind, literals)) => {
1905        let mut tokens = kind.tokens();
1906        for l in literals {
1907          tokens.append(&mut l.tokens());
1908        }
1909        tokens
1910      },
1911      Kind::Record(kinds) => {
1912        let mut tokens = vec![];
1913        for (id, kind) in kinds {
1914          tokens.append(&mut id.tokens());
1915          tokens.append(&mut kind.tokens());
1916        }
1917        tokens
1918      }
1919      Kind::Set(kind, size) => {
1920        let mut tokens = kind.tokens();
1921        if let Some(literal) = size {
1922          tokens.append(&mut literal.tokens());
1923        }
1924        tokens
1925      }
1926      Kind::Table((kinds, literal)) => {
1927        let mut tokens = vec![];
1928        for (id, kind) in kinds {
1929          tokens.append(&mut id.tokens());
1930          tokens.append(&mut kind.tokens());
1931        }
1932        tokens.append(&mut literal.tokens());
1933        tokens
1934      }
1935      Kind::Map(x, y) => x.tokens().into_iter().chain(y.tokens()).collect(),
1936      Kind::Scalar(x) => x.tokens(),
1937      Kind::Atom(x) => x.tokens(),
1938      Kind::Kind(x) => x.tokens(),
1939      Kind::Empty => vec![],
1940      Kind::Any => vec![],
1941    }
1942  }
1943}
1944
1945#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1946#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1947pub enum Literal {
1948  Atom(Atom),
1949  Boolean(Token),
1950  Empty(Token),
1951  Number(Number),
1952  String(MechString),
1953  Kind(Kind),
1954  TypedLiteral((Box<Literal>,KindAnnotation))
1955}
1956
1957impl Literal {
1958  pub fn tokens(&self) -> Vec<Token> {
1959    match self {
1960      Literal::Atom(atm) => atm.name.tokens(),
1961      Literal::Boolean(tkn) => vec![tkn.clone()],
1962      Literal::Number(x) => x.tokens(),
1963      Literal::String(strng) => vec![strng.text.clone()],
1964      Literal::Empty(tkn) => vec![tkn.clone()],
1965      Literal::Kind(knd) => knd.tokens(),
1966      Literal::TypedLiteral((lit, knd)) => {
1967        let mut tokens = lit.tokens();
1968        tokens.append(&mut knd.tokens());
1969        tokens
1970      }
1971    }
1972  }
1973}
1974
1975#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1976#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1977pub struct MechString {
1978  pub text: Token,
1979}
1980
1981impl MechString {
1982  pub fn to_string(&self) -> String {
1983    self.text.to_string()
1984  }
1985}
1986
1987pub type Hyperlink = (Paragraph, Token);
1988
1989#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1990#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1991pub enum ParagraphElement {
1992  Emphasis(Box<ParagraphElement>),
1993  FootnoteReference(Token),
1994  Highlight(Box<ParagraphElement>),
1995  Hyperlink(Hyperlink),
1996  InlineCode(Token),
1997  EvalInlineMechCode(Expression),
1998  InlineMechCode(MechCode),
1999  InlineEquation(Token),
2000  Reference(Token),
2001  SectionReference(Token),
2002  Strikethrough(Box<ParagraphElement>),
2003  Strong(Box<ParagraphElement>),
2004  Text(Token),
2005  Underline(Box<ParagraphElement>),
2006  Error(Token, SourceRange),
2007}
2008
2009impl Recoverable for ParagraphElement {
2010  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
2011    ParagraphElement::Error(skipped_tokens, range)
2012  }
2013}
2014
2015impl ParagraphElement {
2016
2017  pub fn tokens(&self) -> Vec<Token> {
2018    match self {
2019      ParagraphElement::Emphasis(t) => t.tokens(),
2020      ParagraphElement::FootnoteReference(t) => vec![t.clone()],
2021      ParagraphElement::Highlight(t) => t.tokens(),
2022      ParagraphElement::Hyperlink((t, u)) => {
2023        let mut tokens = t.tokens();
2024        tokens.push(u.clone());
2025        tokens
2026      },
2027      ParagraphElement::InlineCode(t) => vec![t.clone()],
2028      ParagraphElement::InlineEquation(t) => vec![t.clone()],
2029      ParagraphElement::InlineMechCode(t) => t.tokens(),
2030      ParagraphElement::EvalInlineMechCode(t) => t.tokens(),
2031      ParagraphElement::Reference(t) => vec![t.clone()],
2032      ParagraphElement::SectionReference(t) => vec![t.clone()],
2033      ParagraphElement::Strikethrough(t) => t.tokens(),
2034      ParagraphElement::Strong(t) => t.tokens(),
2035      ParagraphElement::Text(t) => vec![t.clone()],
2036      ParagraphElement::Underline(t) => t.tokens(),
2037      ParagraphElement::Error(t, _) => vec![t.clone()],
2038    }
2039  }
2040
2041  pub fn to_string(&self) -> String {
2042    match self {
2043      ParagraphElement::Emphasis(t) => t.to_string(),
2044      ParagraphElement::FootnoteReference(t) => t.to_string(),
2045      ParagraphElement::Highlight(t) => t.to_string(),
2046      ParagraphElement::Hyperlink((t, u)) => {
2047        format!("[{}]({})", t.to_string(), u.to_string())
2048      }
2049      ParagraphElement::InlineCode(t) => t.to_string(),
2050      ParagraphElement::InlineEquation(t) => t.to_string(),
2051      ParagraphElement::InlineMechCode(t) => format!("{:?}", t),
2052      ParagraphElement::EvalInlineMechCode(t) => format!("{:?}", t),
2053      ParagraphElement::Reference(t) => t.to_string(),
2054      ParagraphElement::SectionReference(t) => t.to_string(),
2055      ParagraphElement::Strikethrough(t) => t.to_string(),
2056      ParagraphElement::Strong(t) => t.to_string(),
2057      ParagraphElement::Text(t) => t.to_string(),
2058      ParagraphElement::Underline(t) => t.to_string(),
2059      ParagraphElement::Error(t, s) => format!("{{ERROR: {} at {:?}}}", t.to_string(), s),
2060    }
2061  }
2062
2063}
2064
2065#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2066#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2067pub struct Paragraph {
2068  pub elements: Vec<ParagraphElement>,
2069  pub error_range: Option<SourceRange>,
2070}
2071
2072impl Paragraph {
2073  pub fn to_string(&self) -> String {
2074    let mut out = "".to_string();
2075    for e in &self.elements {
2076      out.push_str(&e.to_string());
2077    }
2078    out
2079  }
2080
2081  pub fn from_tokens(tokens: Vec<Token>) -> Paragraph {
2082    let elements = tokens.into_iter().map(|t| ParagraphElement::Text(t)).collect();
2083    Paragraph {
2084      elements,
2085      error_range: None,
2086    }
2087  }
2088
2089  pub fn has_errors(&self) -> bool {
2090    self.error_range.is_some()
2091  }
2092
2093  pub fn tokens(&self) -> Vec<Token> {
2094    let mut tkns = vec![];
2095    for e in &self.elements {
2096      let mut e_tkns = e.tokens();
2097      tkns.append(&mut e_tkns);
2098    }
2099    tkns
2100  }
2101
2102}
2103
2104impl Recoverable for Paragraph {
2105  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
2106    Paragraph {
2107      elements: vec![ParagraphElement::Text(Token::new(TokenKind::Error, range.clone(), skipped_tokens.chars.clone()))],
2108      error_range: Some(range),
2109    }
2110  }
2111}
2112
2113
2114pub type Sign = bool;
2115pub type Numerator = Token;
2116pub type Denominator = Token;
2117pub type Whole = Token;
2118pub type Part = Token;
2119pub type Real = Box<Number>;
2120pub type Imaginary = Box<Number>;
2121pub type Base = (Whole, Part);
2122pub type Exponent = (Sign, Whole, Part);
2123
2124#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2125#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2126pub enum Number {
2127  Real(RealNumber),
2128  Complex(C64Node),
2129}
2130
2131impl Number {
2132
2133  pub fn from_integer(x: i64) -> Number {
2134    Number::Real(RealNumber::Integer(Token::new(TokenKind::Digit, SourceRange::default(), x.to_string().chars().collect())))
2135  }
2136
2137  pub fn to_string(&self) -> String {
2138    match self {
2139      Number::Real(x) => x.to_string(),
2140      Number::Complex(x) => x.to_string(),
2141    }
2142  }
2143
2144  pub fn tokens(&self) -> Vec<Token> {
2145    match self {
2146      Number::Real(x) => x.tokens(),
2147      Number::Complex(x) => x.tokens(),
2148    }
2149  }
2150}
2151
2152#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2153#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2154pub enum RealNumber {
2155  Binary(Token),
2156  Decimal(Token),
2157  Float((Whole,Part)),
2158  Hexadecimal(Token),
2159  Integer(Token),
2160  TypedInteger((Token,KindAnnotation)),
2161  Negated(Box<RealNumber>),
2162  Octal(Token),
2163  Rational((Numerator,Denominator)),
2164  Scientific((Base,Exponent)),
2165}
2166
2167impl RealNumber {
2168  pub fn tokens(&self) -> Vec<Token> {
2169    match self {
2170      RealNumber::Integer(tkn) => vec![tkn.clone()],
2171      RealNumber::TypedInteger((tkn, _)) => vec![tkn.clone()],
2172      RealNumber::Float((whole, part)) => vec![whole.clone(), part.clone()],
2173      RealNumber::Binary(tkn) => vec![tkn.clone()],
2174      RealNumber::Hexadecimal(tkn) => vec![tkn.clone()],
2175      RealNumber::Octal(tkn) => vec![tkn.clone()],
2176      RealNumber::Decimal(tkn) => vec![tkn.clone()],
2177      RealNumber::Rational((num, den)) => vec![num.clone(), den.clone()],
2178      RealNumber::Scientific(((whole,part), exponent)) => {
2179        let mut tokens = vec![whole.clone(), part.clone()];
2180        let (sign, whole_exp, part_exp) = exponent;
2181        tokens.push(Token::new(TokenKind::Plus, SourceRange::default(), if *sign { vec!['+'] } else { vec!['-'] }));
2182        tokens.push(whole_exp.clone());
2183        tokens.push(part_exp.clone());
2184        tokens
2185      }
2186      RealNumber::Negated(x) => {
2187        let mut tokens = vec![Token::new(TokenKind::Dash, SourceRange::default(), vec!['-'])];
2188        tokens.append(&mut x.tokens());
2189        tokens
2190      }
2191    }
2192  }
2193  pub fn to_string(&self) -> String {
2194    match self {
2195      RealNumber::Integer(tkn) => tkn.to_string(),
2196      RealNumber::Float((whole, part)) => format!("{}.{}", whole.to_string(), part.to_string()),
2197      RealNumber::Binary(tkn) => format!("0b{}", tkn.to_string()),
2198      RealNumber::Hexadecimal(tkn) => format!("0x{}", tkn.to_string()),
2199      RealNumber::Octal(tkn) => format!("0o{}", tkn.to_string()),
2200      RealNumber::Decimal(tkn) => format!("0d{}", tkn.to_string()),
2201      RealNumber::Rational((num, den)) => format!("{}/{}", num.to_string(), den.to_string()),
2202      RealNumber::Scientific(((whole,part), exponent)) => {
2203        let (sign, whole, part) = exponent;
2204        let sign_str = if *sign { "+" } else { "-" };
2205        let whole_str = whole.to_string();
2206        let part_str = part.to_string();
2207        format!("{}{}.{}/10^{}", whole.to_string(), part.to_string(), sign_str, whole_str)
2208      }
2209      RealNumber::TypedInteger((tkn, kind)) => format!("{}{}", tkn.to_string(), kind.kind.tokens().iter().map(|t| t.to_string()).collect::<String>()),
2210      RealNumber::Negated(x) => format!("-{}", x.to_string()),
2211    }
2212  }
2213}
2214
2215#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2216#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2217pub struct ImaginaryNumber {
2218  pub number: RealNumber,
2219}
2220
2221#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2222#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2223pub struct C64Node {
2224  pub real: Option<RealNumber>,
2225  pub imaginary: ImaginaryNumber
2226}
2227
2228impl C64Node {
2229  pub fn tokens(&self) -> Vec<Token> {
2230    let mut tkns = vec![];
2231    if let Some(r) = &self.real {
2232      tkns.append(&mut r.tokens());
2233    }
2234    tkns.append(&mut self.imaginary.number.tokens());
2235    tkns
2236  }
2237
2238  pub fn to_string(&self) -> String {
2239    let mut out = "".to_string();
2240    if let Some(r) = &self.real {
2241      out.push_str(&r.to_string());
2242    }
2243    out.push_str("i");
2244    out
2245  }
2246}
2247
2248#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2249#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2250pub struct Comment {
2251  pub paragraph: Paragraph,
2252}
2253
2254impl Comment {
2255  pub fn tokens(&self) -> Vec<Token> {
2256    self.paragraph.tokens()
2257  }
2258}
2259
2260#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2261#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2262pub struct OpAssign {
2263  pub target: SliceRef,
2264  pub op: OpAssignOp,
2265  pub expression: Expression,
2266}
2267
2268impl OpAssign {
2269  pub fn tokens(&self) -> Vec<Token> {
2270    let mut tkns = self.target.tokens();
2271    tkns.append(&mut self.op.tokens());
2272    tkns.append(&mut self.expression.tokens());
2273    tkns
2274  }
2275}
2276
2277#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2278#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2279pub enum OpAssignOp {
2280  Add,
2281  Div,
2282  Exp, 
2283  Mod,  
2284  Mul,
2285  Sub,   
2286}
2287
2288impl OpAssignOp {
2289  pub fn tokens(&self) -> Vec<Token> {
2290    match self {
2291      OpAssignOp::Add => vec![Token::new(TokenKind::Plus, SourceRange::default(), vec!['+'])],
2292      OpAssignOp::Div => vec![Token::new(TokenKind::Slash, SourceRange::default(), vec!['/'])],
2293      OpAssignOp::Exp => vec![Token::new(TokenKind::Caret, SourceRange::default(), vec!['^'])],
2294      OpAssignOp::Mod => vec![Token::new(TokenKind::Percent, SourceRange::default(), vec!['%'])],
2295      OpAssignOp::Mul => vec![Token::new(TokenKind::Asterisk, SourceRange::default(), vec!['*'])],
2296      OpAssignOp::Sub => vec![Token::new(TokenKind::Dash, SourceRange::default(), vec!['-'])],
2297    }
2298  }
2299}
2300
2301#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2302#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2303pub enum RangeOp {
2304  Exclusive,      
2305  Inclusive,
2306}
2307
2308#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2309#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2310pub enum AddSubOp {
2311  Add,
2312  Sub,
2313}
2314
2315#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2316#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2317pub enum MulDivOp {
2318  Div,
2319  Mod,
2320  Mul,
2321}
2322
2323#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2324#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2325pub enum VecOp {
2326  Cross,
2327  Dot,
2328  MatMul,
2329  Solve,
2330}
2331
2332#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2333#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2334pub enum PowerOp {
2335  Pow
2336}
2337
2338#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2339#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2340pub enum ComparisonOp {
2341  Equal,
2342  GreaterThan,
2343  GreaterThanEqual,
2344  LessThan,
2345  LessThanEqual,
2346  NotEqual,
2347  StrictEqual,
2348  StrictNotEqual,
2349}
2350
2351#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2352#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2353pub enum LogicOp {
2354  And,
2355  Not,
2356  Or,
2357  Xor,
2358}
2359
2360#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2361#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2362pub enum FormulaOperator {
2363  AddSub(AddSubOp),
2364  Comparison(ComparisonOp),
2365  Power(PowerOp),
2366  Logic(LogicOp),
2367  MulDiv(MulDivOp),
2368  Vec(VecOp),
2369  Table(TableOp),
2370  Set(SetOp),
2371}
2372
2373#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2374#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2375pub enum TableOp {
2376  InnerJoin,
2377  LeftOuterJoin,
2378  RightOuterJoin	,
2379  FullOuterJoin	,
2380  LeftSemiJoin,  
2381  LeftAntiJoin,
2382}
2383
2384#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2385#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2386pub enum SetOp {
2387  Union,
2388  Intersection,
2389  Difference,
2390  Complement,
2391  ElementOf,
2392  NotElementOf,
2393  ProperSubset,
2394  ProperSuperset,
2395  Subset,
2396  Superset,
2397  SymmetricDifference,
2398}
2399
2400#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2401#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2402pub struct RangeExpression {
2403  pub start: Factor,
2404  pub increment: Option<(RangeOp,Factor)>,
2405  pub operator: RangeOp,
2406  pub terminal: Factor,
2407}
2408
2409impl RangeExpression {
2410  pub fn tokens(&self) -> Vec<Token> {
2411    let mut tokens = self.start.tokens();
2412    tokens.append(&mut self.terminal.tokens());
2413    tokens
2414  }
2415}
2416
2417#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2418#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2419pub struct Term {
2420  pub lhs: Factor,
2421  pub rhs: Vec<(FormulaOperator,Factor)>
2422}
2423
2424impl Term {
2425  pub fn tokens(&self) -> Vec<Token> {
2426    let mut lhs_tkns = self.lhs.tokens();
2427    let mut rhs_tkns = vec![];
2428    for (op, r) in &self.rhs {
2429      let mut tkns = r.tokens();
2430      rhs_tkns.append(&mut tkns);
2431    }
2432    lhs_tkns.append(&mut rhs_tkns);
2433    lhs_tkns
2434  }
2435}
2436
2437#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2438#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2439pub enum Factor {
2440  Expression(Box<Expression>),
2441  Negate(Box<Factor>),
2442  Not(Box<Factor>),
2443  Parenthetical(Box<Factor>),
2444  Term(Box<Term>),
2445  Transpose(Box<Factor>),
2446}
2447
2448impl Factor {
2449  pub fn tokens(&self) -> Vec<Token> {
2450    match self {
2451      Factor::Expression(x) => x.tokens(),
2452      Factor::Negate(x) => x.tokens(),
2453      Factor::Not(x) => x.tokens(),
2454      Factor::Parenthetical(x) => x.tokens(),
2455      Factor::Term(x) => x.tokens(),
2456      Factor::Transpose(x) => x.tokens(),
2457    }
2458  }
2459}
mech_core/nodes.rs

mech_core/
nodes.rs
