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

mech_core/
nodes.rs
