mech_core/
nodes.rs

1use std::cmp::Ordering;
2use crate::*; 
3use std::fmt;
4use std::io::{Write, Cursor, Read};
5
6
7pub fn compress_and_encode<T: serde::Serialize>(tree: &T) -> Result<String, Box<dyn std::error::Error>> {
8  let serialized_code = bincode::serde::encode_to_vec(tree,bincode::config::standard())?;
9  let mut compressed = Vec::new();
10  brotli::CompressorWriter::new(&mut compressed, 9, 4096, 22)
11      .write(&serialized_code)?;
12  Ok(base64::encode(compressed))
13}
14
15pub fn decode_and_decompress<T: serde::de::DeserializeOwned>(encoded: &str) -> Result<T, Box<dyn std::error::Error>> {
16  let decoded = base64::decode(encoded)?;
17  
18  let mut decompressed = Vec::new();
19  brotli::Decompressor::new(Cursor::new(decoded), 4096)
20      .read_to_end(&mut decompressed)?;
21  
22  let (decoded,red) = bincode::serde::decode_from_slice(&decompressed,bincode::config::standard())?;
23
24  Ok(decoded)
25}
26
27#[derive(Clone, Copy, Ord, PartialEq, Eq, Hash, Serialize, Deserialize)]
28pub struct SourceLocation {
29  pub row: usize,
30  pub col: usize,
31}
32
33impl PartialOrd for SourceLocation {
34  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
35    if self.row < other.row {
36      Some(Ordering::Less)
37    } else if self.row > other.row {
38      Some(Ordering::Greater)
39    } else {
40      self.col.partial_cmp(&other.col)
41    }
42  }
43}
44
45impl fmt::Debug for SourceLocation {
46  #[inline]
47  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
48    write!(f, "{}:{}", self.row, self.col);
49    Ok(())
50  }
51}
52
53#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
54pub struct SourceRange {
55  pub start: SourceLocation,
56  pub end:   SourceLocation,
57}
58
59/// Coordinates in SourceRange are 1-indexed, i.e. they directly translate
60/// human's view to line and column numbers.  Having value 0 means the 
61/// range is not initialized.
62impl Default for SourceRange {
63  fn default() -> Self {
64    SourceRange {
65      start: SourceLocation { row: 0, col: 0 },
66      end:   SourceLocation { row: 0, col: 0 },
67    }
68  }
69}
70
71impl fmt::Debug for SourceRange {
72  #[inline]
73  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
74    write!(f, "[{:?}, {:?})", self.start, self.end);
75    Ok(())
76  }
77}
78
79pub fn merge_src_range(r1: SourceRange, r2: SourceRange) -> SourceRange {
80  SourceRange {
81    start: r1.start.min(r2.start),
82    end:   r2.end.max(r2.end),
83  }
84}
85
86#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
87pub enum TokenKind {
88  AbstractSigil, Alpha, Ampersand, Any, Apostrophe, AssignOperator, Asterisk, AsyncTransitionOperator, At,
89  Backslash, Bar, BoxDrawing,
90  Caret, CarriageReturn, CarriageReturnNewLine, Colon, CodeBlock, Comma,
91  Dash, DefineOperator, Digit, Dollar,
92  Emoji, EmphasisSigil, Empty, Equal, EquationSigil, Exclamation, 
93  False, FloatLeft, FloatRight, FootnotePrefix,
94  Grave,
95  HashTag, HighlightSigil, HttpPrefix,
96  Identifier, ImgPrefix, InlineCode, 
97  LeftAngle, LeftBrace, LeftBracket, LeftParenthesis,
98  Newline, Not, Number,
99  OutputOperator,
100  Percent, Period, Plus,
101  QuerySigil, Question, Quote, QuoteSigil,
102  RightAngle, RightBrace, RightBracket, RightParenthesis,
103  Semicolon, Space, Slash, String, StrikeSigil, StrongSigil,
104  Tab, Text, Tilde, Title, TransitionOperator, True,
105  UnderlineSigil, Underscore,
106}
107
108#[derive(Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
109pub struct Token { 
110  pub kind: TokenKind, 
111  pub chars: Vec<char>, 
112  pub src_range: SourceRange 
113}
114
115impl fmt::Debug for Token {
116  #[inline]
117  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
118    write!(f, "{:?}:{:?}:{:?}", self.kind, String::from_iter(self.chars.iter().cloned()), self.src_range);
119    Ok(())
120  }
121}
122
123impl Default for Token {
124  fn default() -> Self {
125    Token{
126      kind: TokenKind::Empty,
127      chars: vec![],
128      src_range: SourceRange::default(),
129    }
130  }
131}
132
133impl Token {
134
135  pub fn new(kind: TokenKind, src_range: SourceRange, chars: Vec<char>) -> Token {
136    Token{kind, chars, src_range}
137  }
138
139  pub fn to_string(&self) -> String {
140    self.chars.iter().collect()
141  }
142
143  pub fn merge_tokens(tokens: &mut Vec<Token>) -> Option<Token> {
144    if tokens.len() == 0 {
145      None
146    } else if tokens.len() == 1 {
147      Some(tokens[0].clone())
148    } else {
149      let first = tokens[0].src_range.clone();
150      let kind = tokens[0].kind.clone();
151      let last = tokens.last().unwrap().src_range.clone();
152      let src_range = merge_src_range(first, last);
153      let chars: Vec<char> = tokens.iter_mut().fold(vec![],|mut m, ref mut t| {m.append(&mut t.chars.clone()); m});
154      let merged_token = Token{kind, chars, src_range};
155      Some(merged_token)
156    }
157  }
158}
159
160#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
161pub struct TableOfContents {
162    pub title: Option<Title>,
163    pub sections: Vec<Section>,
164}
165
166#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
167pub struct Program {
168  pub title: Option<Title>,
169  pub body: Body,
170}
171
172impl Program {
173  pub fn tokens(&self) -> Vec<Token> {
174    /*let mut title_tokens = match self.title.tokens() {
175      Some(tkns) => tkns,
176      None => vec![],
177    };*/
178    let body_tokens = self.body.tokens();
179    body_tokens
180  }
181
182  pub fn table_of_contents(&self) -> TableOfContents {
183    let mut sections = vec![];
184    for s in &self.body.sections {
185      sections.push(s.table_of_contents());
186    }
187    TableOfContents {
188      title: self.title.clone(),
189      sections,
190    }
191  }
192
193  pub fn pretty_print(&self) -> String {
194    let json_string = serde_json::to_string_pretty(self).unwrap();
195  
196    let depth = |line: &str|->usize{line.chars().take_while(|&c| c == ' ').count()};
197    let mut result = String::new();
198    let lines: Vec<&str> = json_string.lines().collect();
199    result.push_str("Program\n");
200    for (index, line) in lines.iter().enumerate() {
201      let trm = line.trim();
202      if trm == "}" || 
203         trm == "},"|| 
204         trm == "{" || 
205         trm == "[" || 
206         trm == "],"|| 
207         trm == "]" {
208        continue;
209      }
210  
211      // Count leading spaces to determine depth
212      let d = depth(line);
213      // Construct the tree-like prefix
214      let mut prefix = String::new();
215      for _ in 0..d {
216        prefix.push_str(" ");
217      }
218      if index == lines.len() {
219        prefix.push_str("└ ");
220      } else {
221        if depth(lines[index + 1]) != d {
222          prefix.push_str("└ ");
223        } else {
224          prefix.push_str("├ ");
225        }
226      }
227      let trm = line.trim();
228      let trm = trm.trim_end_matches('{')
229                    .trim_start_matches('"')
230                    .trim_end_matches(':')
231                    .trim_end_matches('"')
232                    .trim_end_matches('[');
233      prefix.push_str(trm);
234  
235      // Append formatted line to result
236      result.push_str(&prefix);
237      result.push('\n');
238      result = result.replace("\":", "");
239    }
240    let mut indexed_str = IndexedString::new(&result);
241    'rows: for i in 0..indexed_str.rows {
242      let rowz = &indexed_str.index_map[i];
243      for j in 0..rowz.len() {
244        let c = match indexed_str.get(i,j) {
245          Some(c) => c,
246          None => continue,
247        };
248        if c == '└' {
249          for k in i+1..indexed_str.rows {
250            match indexed_str.get(k,j) {
251              Some(c2) => {
252                if c2 == '└' {
253                  indexed_str.set(i,j,'├');
254                  for l in i+1..k {
255                    match indexed_str.get(l,j) {
256                      Some(' ') => {indexed_str.set(l,j,'│');},
257                      Some('└') => {indexed_str.set(l,j,'├');},
258                      _ => (),
259                    }
260                  }
261                } else if c2 == ' ' {
262                  continue;
263                } else {
264                  continue 'rows;
265                }
266              },
267              None => continue,
268            }
269  
270          }
271        } else if c == ' ' || c == '│' {
272          continue;
273        } else {
274          continue 'rows;
275        }
276      }
277    }
278    indexed_str.to_string()
279  }
280
281}
282
283#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
284pub struct Title {
285  pub text: Token,
286}
287
288impl Title {
289
290  pub fn to_string(&self) -> String {
291    self.text.to_string()
292  }
293
294}
295
296#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
297pub struct Body {
298  pub sections: Vec<Section>,
299}
300
301impl Body {
302  pub fn tokens(&self) -> Vec<Token> {
303    let mut out = vec![];
304    for s in &self.sections {
305      let mut tkns = s.tokens();
306      out.append(&mut tkns);
307    }
308    out
309  }
310}
311
312#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
313pub enum ColumnAlignment {
314  Left,
315  Center,
316  Right,
317}
318
319#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
320pub struct MarkdownTable {
321  pub header: Vec<Paragraph>,
322  pub rows: Vec<Vec<Paragraph>>,
323  pub alignment: Vec<ColumnAlignment>,
324}
325
326#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
327pub struct Subtitle {
328  pub text: Paragraph,
329  pub level: u8,
330}
331
332impl Subtitle {
333  pub fn to_string(&self) -> String {
334    self.text.to_string()
335  }
336}
337
338#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
339pub struct Section {
340  pub subtitle: Option<Subtitle>,
341  pub elements: Vec<SectionElement>,
342}
343
344impl Section {
345
346  pub fn table_of_contents(&self) -> Section {
347    let elements: Vec<_> = self.elements.iter()
348      .filter(|e| matches!(e, SectionElement::Subtitle(_)))
349      .cloned()
350      .collect();
351    Section {
352      subtitle: self.subtitle.clone(),
353      elements,
354    }
355  }
356
357  pub fn tokens(&self) -> Vec<Token> {
358    let mut out = vec![];
359    for s in &self.elements {
360      let mut tkns = s.tokens();
361      out.append(&mut tkns);
362    }
363    out
364  }
365}
366
367#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
368pub struct Grammar {
369  pub rules: Vec<Rule>,
370}
371
372#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
373pub struct GrammarIdentifier {
374  pub name: Token,
375}
376
377impl GrammarIdentifier {
378  pub fn tokens(&self) -> Vec<Token> {
379    vec![self.name.clone()]
380  }
381
382  pub fn to_string(&self) -> String {
383    self.name.to_string()
384  }
385}
386
387#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
388pub struct Rule {
389  pub name: GrammarIdentifier,
390  pub expr: GrammarExpression,
391}
392
393#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
394pub enum GrammarExpression {
395  Choice(Vec<GrammarExpression>),
396  Definition(GrammarIdentifier),
397  Group(Box<GrammarExpression>),
398  List(Box<GrammarExpression>, Box<GrammarExpression>),
399  Not(Box<GrammarExpression>),
400  Optional(Box<GrammarExpression>),
401  Peek(Box<GrammarExpression>),
402  Repeat0(Box<GrammarExpression>),
403  Repeat1(Box<GrammarExpression>),
404  Range(Token,Token),
405  Sequence(Vec<GrammarExpression>),
406  Terminal(Token),
407}
408
409#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
410pub struct Citation {
411  pub id: Token,
412  pub text: Paragraph,
413}
414
415impl Citation {
416  pub fn to_string(&self) -> String {
417    format!("[{}]: {}", self.id.to_string(), self.text.to_string())
418  }
419}
420// This is just a temporary flag to store block state, 
421// I don't know exactly what I want to put in here yet
422type BlockConfig = u64; 
423
424pub type Footnote = (Token, Paragraph);
425
426#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
427pub enum FloatDirection {
428  Left,
429  Right,
430}
431
432#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
433pub enum SectionElement {
434  Abstract(Paragraph),
435  BlockQuote(Paragraph),
436  Citation(Citation),
437  CodeBlock(Token),
438  Comment(Comment),
439  Equation(Token),
440  FencedMechCode((Vec<MechCode>, BlockConfig)),
441  Float((Box<SectionElement>, FloatDirection)),
442  Footnote(Footnote),
443  Grammar(Grammar),
444  Image(Image),
445  List(MDList),
446  MechCode(Vec<MechCode>),
447  Paragraph(Paragraph),
448  Subtitle(Subtitle),
449  Table(MarkdownTable),
450  ThematicBreak,
451}
452
453impl SectionElement {
454  pub fn tokens(&self) -> Vec<Token> {
455    match self {
456      SectionElement::MechCode(codes) => {
457        let mut tokens = vec![];
458        for code in codes {
459          tokens.append(&mut code.tokens());
460        }
461        tokens
462      },
463      _ => todo!(),
464    }
465  }
466}
467
468#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
469pub struct Image {
470  pub src: Token,
471  pub caption: Option<Paragraph>,
472}
473
474impl Image {
475  pub fn to_string(&self) -> String {
476    let caption = match &self.caption {
477      Some(c) => c.to_string(),
478      None => "".to_string(),
479    };
480    format!("![{}]({})", caption, self.src.to_string())
481  }
482}
483
484pub type UnorderedList = Vec<((Option<Token>,Paragraph),Option<MDList>)>;
485pub type CheckList = Vec<((bool,Paragraph),Option<MDList>)>;
486
487#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
488pub struct OrderedList {
489  pub start: Number,
490  pub items: Vec<((Number,Paragraph),Option<MDList>)>,
491}
492
493#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
494pub enum MDList {
495  Unordered(UnorderedList),
496  Ordered(OrderedList),
497  Check(CheckList)
498}
499
500#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
501pub enum MechCode {
502  Comment(Comment),
503  Expression(Expression),
504  FsmImplementation(FsmImplementation),
505  FsmSpecification(FsmSpecification),
506  FunctionDefine(FunctionDefine),
507  Statement(Statement),
508}
509
510impl MechCode {
511  pub fn tokens(&self) -> Vec<Token> {
512    match self {
513      MechCode::Expression(x) => x.tokens(),
514      _ => todo!(),
515      //Statement(x) => x.tokens(),
516      //FunctionDefine(x) => x.tokens(),
517      //FsmSpecification(x) => x.tokens(),
518      //FsmImplementation(x) => x.tokens(),
519    }
520  }
521}
522
523#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
524pub struct FunctionDefine {
525  pub name: Identifier,
526  pub input: Vec<FunctionArgument>,
527  pub output: Vec<FunctionArgument>,
528  pub statements: Vec<Statement>,
529}
530
531#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
532pub struct FunctionArgument {
533  pub name: Identifier,
534  pub kind: KindAnnotation,
535}
536
537impl FunctionArgument {
538  pub fn tokens(&self) -> Vec<Token> {
539    let mut tokens = self.name.tokens();
540    tokens.append(&mut self.kind.tokens());
541    tokens
542  }
543}
544
545#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
546pub struct FsmImplementation {
547  pub name: Identifier,
548  pub input: Vec<Identifier>,
549  pub start: Pattern,
550  pub arms: Vec<FsmArm>,
551}
552
553#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
554pub enum FsmArm {
555  Guard(Pattern,Vec<Guard>),
556  Transition(Pattern,Vec<Transition>),
557}
558
559#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
560pub struct Guard { 
561  pub condition: Pattern,
562  pub transitions: Vec<Transition>,
563}
564
565#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
566pub enum Transition {
567  Async(Pattern),
568  CodeBlock(Vec<MechCode>),
569  Next(Pattern),
570  Output(Pattern),
571  Statement(Statement),
572}
573
574#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
575pub enum Pattern {
576  Expression(Expression),
577  Formula(Factor),
578  TupleStruct(PatternTupleStruct),
579  Wildcard,
580}
581
582#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
583pub struct PatternTupleStruct {
584  pub name: Identifier,
585  pub patterns: Vec<Pattern>,
586}
587
588pub type PatternTuple = Vec<Pattern>;
589
590#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
591pub struct FsmSpecification {
592  pub name: Identifier,
593  pub input: Vec<Var>,
594  pub output: Option<KindAnnotation>,
595  pub states: Vec<StateDefinition>,
596}
597
598#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
599pub struct StateDefinition {
600  pub name: Identifier,
601  pub state_variables: Option<Vec<Var>>,
602}
603
604#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
605pub enum Statement {
606  EnumDefine(EnumDefine),
607  FsmDeclare(FsmDeclare),
608  KindDefine(KindDefine),
609  OpAssign(OpAssign),
610  VariableAssign(VariableAssign),
611  VariableDefine(VariableDefine),
612  SplitTable,     // todo
613  FlattenTable,   // todo
614}
615
616#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
617pub struct FsmPipe {
618  pub start: FsmInstance,
619  pub transitions: Vec<Transition>
620}
621
622#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
623pub enum PipeElement {
624  Expression(Expression),
625  FsmInstance(FsmInstance),
626  Timer // todo
627}
628
629#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
630pub struct FsmDeclare {
631  pub fsm: Fsm,
632  pub pipe: FsmPipe,
633}
634
635#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
636pub struct Fsm {
637  pub name: Identifier,
638  pub args: Option<ArgumentList>,
639  pub kind: Option<KindAnnotation>
640}
641
642pub type FsmArgs = Vec<(Option<Identifier>,Expression)>;
643
644#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
645pub struct FsmInstance {
646  pub name: Identifier,
647  pub args: Option<FsmArgs>,
648}
649
650#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
651pub struct EnumDefine {
652  pub name: Identifier,
653  pub variants: Vec<EnumVariant>,
654}
655
656#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
657pub struct EnumVariant {
658  pub name: Identifier,
659  pub value: Option<KindAnnotation>,
660}
661
662#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
663pub struct KindDefine {
664  pub name: Identifier,
665  pub kind: KindAnnotation,
666}
667
668#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
669pub struct Record {
670  pub bindings: Vec<Binding>,
671}
672
673#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
674pub enum Structure {
675  Empty,
676  Map(Map),
677  Matrix(Matrix),
678  Record(Record),
679  Set(Set),
680  Table(Table),
681  Tuple(Tuple),
682  TupleStruct(TupleStruct),
683}
684
685impl Structure {
686  pub fn tokens(&self) -> Vec<Token> {
687    match self {
688      Structure::Matrix(mat) => mat.tokens(),
689      _ => todo!(),
690    }
691  }
692}
693
694#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
695pub struct Map {
696  pub elements: Vec<Mapping>,
697}
698
699#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
700pub struct Mapping {
701  pub key: Expression,
702  pub value: Expression,
703}
704
705#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
706pub struct Set {
707  pub elements: Vec<Expression>,
708}
709
710#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
711pub struct Atom {
712  pub name: Identifier,
713}
714
715#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
716pub struct TupleStruct {
717  pub name: Identifier,
718  pub value: Box<Expression>,
719}
720
721#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
722pub struct Matrix {
723  pub rows: Vec<MatrixRow>,
724}
725
726impl Matrix {
727  pub fn tokens(&self) -> Vec<Token> {
728    let mut tkns = vec![];
729    for r in &self.rows {
730      let mut t = r.tokens();
731      tkns.append(&mut t);
732    }
733    tkns
734  }
735}
736
737pub type TableHeader = Vec<Field>;
738
739#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
740pub struct Table {
741  pub header: TableHeader,
742  pub rows: Vec<TableRow>,
743}
744
745#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
746pub struct Field {
747  pub name: Identifier,
748  pub kind: Option<KindAnnotation>,
749}
750
751#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
752pub struct TableColumn {
753  pub element: Expression,
754}
755
756#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
757pub struct MatrixColumn {
758  pub element: Expression,
759}
760
761impl MatrixColumn {
762  pub fn tokens(&self) -> Vec<Token> {
763    self.element.tokens()
764  }
765}
766
767#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
768pub struct TableRow {
769  pub columns: Vec<TableColumn>,
770}
771
772#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
773pub struct MatrixRow {
774  pub columns: Vec<MatrixColumn>,
775}
776
777impl MatrixRow {
778  pub fn tokens(&self) -> Vec<Token> {
779    let mut tkns = vec![];
780    for r in &self.columns {
781      let mut t = r.tokens();
782      tkns.append(&mut t);
783    }
784    tkns
785  }
786}
787
788#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
789pub struct VariableDefine {
790  pub mutable: bool,
791  pub var: Var,
792  pub expression: Expression,
793}
794
795#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
796pub struct Var {
797  pub name: Identifier,
798  pub kind: Option<KindAnnotation>,
799}
800
801impl Var {
802  pub fn tokens(&self) -> Vec<Token> {
803    let mut tkns = self.name.tokens();
804    if let Some(knd) = &self.kind {
805      let mut t = knd.tokens();
806      tkns.append(&mut t);
807    }
808    tkns
809  }
810}
811
812
813#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
814pub struct VariableAssign {
815  pub target: SliceRef,
816  pub expression: Expression,
817}
818
819#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
820pub struct Identifier {
821  pub name: Token,
822}
823
824impl Identifier {
825  pub fn tokens(&self) -> Vec<Token> {
826    vec![self.name.clone()]
827  }
828
829  pub fn to_string(&self) -> String {
830    self.name.to_string()
831  }
832
833}
834
835
836impl Identifier {
837  pub fn hash(&self) -> u64 {
838    hash_chars(&self.name.chars)
839  }
840}
841
842#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
843pub struct Emoji {
844  pub tokens: Vec<Token>,
845}
846
847#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
848pub struct Word {
849  pub tokens: Vec<Token>,
850}
851
852#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
853pub struct Slice {
854  pub name: Identifier,
855  pub subscript: Vec<Subscript>
856}
857
858#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
859pub struct SliceRef {
860  pub name: Identifier,
861  pub subscript: Option<Vec<Subscript>>
862}
863
864#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
865pub enum Subscript {
866  All,                      // a[:]
867  Brace(Vec<Subscript>),    // a{"foo"}
868  Bracket(Vec<Subscript>),  // a[1,2,3]
869  Dot(Identifier),          // a.b
870  DotInt(RealNumber),       // a.1
871  Formula(Factor),          // a[1 + 1]
872  Range(RangeExpression),   // a[1 + 1]
873  Swizzle(Vec<Identifier>), // a.b,c
874}
875
876#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
877pub enum Expression {
878  Formula(Factor),
879  FunctionCall(FunctionCall),
880  FsmPipe(FsmPipe),
881  Literal(Literal),
882  Range(Box<RangeExpression>),
883  Slice(Slice),
884  Structure(Structure),
885  Var(Var),
886}
887
888impl Expression {
889  pub fn tokens(&self) -> Vec<Token> {
890    match self {
891      Expression::Var(v) => v.tokens(),
892      Expression::Literal(ltrl) => ltrl.tokens(),
893      Expression::Structure(strct) => strct.tokens(),
894      Expression::Formula(fctr) => fctr.tokens(),
895      _ => todo!(),
896    }
897  }
898}
899
900pub type ArgumentList = Vec<(Option<Identifier>,Expression)>;
901
902#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
903pub struct FunctionCall {
904  pub name: Identifier,
905  pub args: ArgumentList,
906}
907
908impl FunctionCall {
909  pub fn tokens(&self) -> Vec<Token> {
910    self.name.tokens()
911  }
912}
913
914#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
915pub struct Tuple {
916  pub elements: Vec<Expression>
917}
918
919#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
920pub struct Binding {
921  pub name: Identifier,
922  pub kind: Option<KindAnnotation>,
923  pub value: Expression,
924}
925
926#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
927pub struct KindAnnotation {
928  pub kind: Kind
929}
930
931impl KindAnnotation {
932
933  pub fn hash(&self) -> u64 {
934    match &self.kind {
935      Kind::Scalar(id) => id.hash(),
936      _ => todo!(),
937    }
938  }
939
940  pub fn tokens(&self) -> Vec<Token> {
941    self.kind.tokens()
942  }
943}
944
945#[derive(Clone, Debug, Hash, Serialize, Deserialize,Eq, PartialEq)]
946pub enum Kind {
947  Atom(Identifier),
948  Brace((Vec<Kind>,Vec<Literal>)),
949  Bracket((Vec<Kind>,Vec<Literal>)),
950  Empty,
951  Fsm(Vec<Kind>,Vec<Kind>),
952  Function(Vec<Kind>,Vec<Kind>),
953  Map(Box<Kind>,Box<Kind>),
954  Scalar(Identifier),
955  Tuple(Vec<Kind>),
956}
957
958impl Kind {
959  pub fn tokens(&self) -> Vec<Token> {
960    match self {
961      Kind::Tuple(x) => x.iter().flat_map(|k| k.tokens()).collect(),
962      Kind::Bracket((kinds, literals)) => {
963        kinds.iter().flat_map(|k| k.tokens())
964            .chain(literals.iter().flat_map(|l| l.tokens()))
965            .collect()
966      },
967      Kind::Brace((kinds, literals)) => {
968        kinds.iter().flat_map(|k| k.tokens())
969            .chain(literals.iter().flat_map(|l| l.tokens()))
970            .collect()
971      }
972      Kind::Map(x, y) => x.tokens().into_iter().chain(y.tokens()).collect(),
973      Kind::Scalar(x) => x.tokens(),
974      Kind::Atom(x) => x.tokens(),
975      Kind::Function(args, rets) => {
976        args.iter().flat_map(|k| k.tokens())
977            .chain(rets.iter().flat_map(|k| k.tokens()))
978            .collect()
979      }
980      Kind::Fsm(args, rets) => {
981        args.iter().flat_map(|k| k.tokens())
982            .chain(rets.iter().flat_map(|k| k.tokens()))
983            .collect()
984      }
985      Kind::Empty => vec![],
986    }
987  }
988}
989
990#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
991pub enum Literal {
992  Atom(Atom),
993  Boolean(Token),
994  Empty(Token),
995  Number(Number),
996  String(MechString),
997  TypedLiteral((Box<Literal>,KindAnnotation))
998}
999
1000impl Literal {
1001  pub fn tokens(&self) -> Vec<Token> {
1002    match self {
1003      Literal::Atom(atm) => atm.name.tokens(),
1004      Literal::Boolean(tkn) => vec![tkn.clone()],
1005      Literal::Number(x) => x.tokens(),
1006      Literal::String(strng) => vec![strng.text.clone()],
1007      _ => todo!(),
1008    }
1009  }
1010}
1011
1012#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1013pub struct MechString {
1014  pub text: Token,
1015}
1016
1017pub type Hyperlink = (Token, Token);
1018
1019#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1020pub enum ParagraphElement {
1021  Emphasis(Box<ParagraphElement>),
1022  FootnoteReference(Token),
1023  Highlight(Box<ParagraphElement>),
1024  Hyperlink(Hyperlink),
1025  InlineCode(Token),
1026  InlineMechCode(Expression),
1027  InlineEquation(Token),
1028  Reference(Token),
1029  Strikethrough(Box<ParagraphElement>),
1030  Strong(Box<ParagraphElement>),
1031  Text(Token),
1032  Underline(Box<ParagraphElement>),
1033}
1034
1035impl ParagraphElement {
1036
1037  pub fn to_string(&self) -> String {
1038    match self {
1039      ParagraphElement::Emphasis(t) => t.to_string(),
1040      ParagraphElement::FootnoteReference(t) => t.to_string(),
1041      ParagraphElement::Highlight(t) => t.to_string(),
1042      ParagraphElement::Hyperlink((t, u)) => {
1043        format!("[{}]({})", t.to_string(), u.to_string())
1044      }
1045      ParagraphElement::InlineCode(t) => t.to_string(),
1046      ParagraphElement::InlineEquation(t) => t.to_string(),
1047      ParagraphElement::InlineMechCode(t) => format!("{:?}", t),
1048      ParagraphElement::Reference(t) => t.to_string(),
1049      ParagraphElement::Strikethrough(t) => t.to_string(),
1050      ParagraphElement::Strong(t) => t.to_string(),
1051      ParagraphElement::Text(t) => t.to_string(),
1052      ParagraphElement::Underline(t) => t.to_string(),
1053    }
1054  }
1055
1056}
1057
1058#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1059pub struct Paragraph {
1060  pub elements: Vec<ParagraphElement>,
1061}
1062
1063impl Paragraph {
1064  pub fn to_string(&self) -> String {
1065    let mut out = "".to_string();
1066    for e in &self.elements {
1067      out.push_str(&e.to_string());
1068    }
1069    out
1070  }
1071}
1072
1073pub type Sign = bool;
1074pub type Numerator = Token;
1075pub type Denominator = Token;
1076pub type Whole = Token;
1077pub type Part = Token;
1078pub type Real = Box<Number>;
1079pub type Imaginary = Box<Number>;
1080pub type Base = (Whole, Part);
1081pub type Exponent = (Sign, Whole, Part);
1082
1083#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
1084pub enum Number {
1085  Real(RealNumber),
1086  Imaginary(ComplexNumber),
1087}
1088
1089impl Number {
1090
1091  pub fn to_string(&self) -> String {
1092    match self {
1093      Number::Real(x) => x.to_string(),
1094      Number::Imaginary(x) => x.to_string(),
1095    }
1096  }
1097
1098  pub fn tokens(&self) -> Vec<Token> {
1099    match self {
1100      Number::Real(x) => x.tokens(),
1101      _ => todo!(),
1102    }
1103  }
1104}
1105
1106#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
1107pub enum RealNumber {
1108  Binary(Token),
1109  Decimal(Token),
1110  Float((Whole,Part)),
1111  Hexadecimal(Token),
1112  Integer(Token),
1113  Negated(Box<RealNumber>),
1114  Octal(Token),
1115  Rational((Numerator,Denominator)),
1116  Scientific((Base,Exponent)),
1117}
1118
1119impl RealNumber {
1120  pub fn tokens(&self) -> Vec<Token> {
1121    match self {
1122      RealNumber::Integer(tkn) => vec![tkn.clone()],
1123      _ => todo!(),
1124    }
1125  }
1126  pub fn to_string(&self) -> String {
1127    match self {
1128      RealNumber::Integer(tkn) => tkn.to_string(),
1129      RealNumber::Float((whole, part)) => format!("{}.{}", whole.to_string(), part.to_string()),
1130      RealNumber::Binary(tkn) => format!("0b{}", tkn.to_string()),
1131      RealNumber::Hexadecimal(tkn) => format!("0x{}", tkn.to_string()),
1132      RealNumber::Octal(tkn) => format!("0o{}", tkn.to_string()),
1133      RealNumber::Decimal(tkn) => format!("0d{}", tkn.to_string()),
1134      RealNumber::Rational((num, den)) => format!("{}/{}", num.to_string(), den.to_string()),
1135      RealNumber::Scientific(((whole,part), exponent)) => {
1136        let (sign, whole, part) = exponent;
1137        let sign_str = if *sign { "+" } else { "-" };
1138        let whole_str = whole.to_string();
1139        let part_str = part.to_string();
1140        format!("{}{}.{}/10^{}", whole.to_string(), part.to_string(), sign_str, whole_str)
1141      }
1142      RealNumber::Negated(x) => format!("-{}", x.to_string()),
1143    }
1144  }
1145}
1146
1147#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
1148pub struct ImaginaryNumber {
1149  pub number: RealNumber,
1150}
1151
1152#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
1153pub struct ComplexNumber {
1154  pub real: Option<RealNumber>,
1155  pub imaginary: ImaginaryNumber
1156}
1157
1158impl ComplexNumber {
1159  pub fn tokens(&self) -> Vec<Token> {
1160    let mut tkns = vec![];
1161    if let Some(r) = &self.real {
1162      tkns.append(&mut r.tokens());
1163    }
1164    tkns.append(&mut self.imaginary.number.tokens());
1165    tkns
1166  }
1167
1168  pub fn to_string(&self) -> String {
1169    let mut out = "".to_string();
1170    if let Some(r) = &self.real {
1171      out.push_str(&r.to_string());
1172    }
1173    out.push_str("i");
1174    out
1175  }
1176}
1177
1178#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1179pub struct Comment {
1180  pub text: Token,
1181}
1182
1183#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1184pub struct OpAssign {
1185  pub target: SliceRef,
1186  pub op: OpAssignOp,
1187  pub expression: Expression,
1188}
1189
1190#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1191pub enum OpAssignOp {
1192  Add,
1193  Div,
1194  Exp, 
1195  Mod,  
1196  Mul,
1197  Sub,   
1198}
1199
1200#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1201pub enum RangeOp {
1202  Exclusive,      
1203  Inclusive,
1204}
1205
1206#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1207pub enum AddSubOp {
1208  Add,
1209  Sub,
1210}
1211
1212#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1213pub enum MulDivOp {
1214  Div,
1215  Mod,
1216  Mul,
1217}
1218
1219#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1220pub enum VecOp {
1221  Cross,
1222  Dot,
1223  MatMul,
1224  Solve,
1225}
1226
1227#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1228pub enum ExponentOp {
1229  Exp
1230}
1231
1232#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1233pub enum ComparisonOp {
1234  Equal,
1235  GreaterThan,
1236  GreaterThanEqual,
1237  LessThan,
1238  LessThanEqual,
1239  NotEqual,
1240}
1241
1242#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1243pub enum LogicOp {
1244  And,
1245  Not,
1246  Or,
1247  Xor,
1248}
1249
1250#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1251pub enum FormulaOperator {
1252  AddSub(AddSubOp),
1253  Comparison(ComparisonOp),
1254  Exponent(ExponentOp),
1255  Logic(LogicOp),
1256  MulDiv(MulDivOp),
1257  Vec(VecOp),
1258}
1259
1260#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1261pub struct RangeExpression {
1262  pub start: Factor,
1263  pub increment: Option<(RangeOp,Factor)>,
1264  pub operator: RangeOp,
1265  pub terminal: Factor,
1266}
1267
1268impl RangeExpression {
1269  pub fn tokens(&self) -> Vec<Token> {
1270    let mut tokens = self.start.tokens();
1271    tokens.append(&mut self.terminal.tokens());
1272    tokens
1273  }
1274}
1275
1276#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1277pub struct Term {
1278  pub lhs: Factor,
1279  pub rhs: Vec<(FormulaOperator,Factor)>
1280}
1281
1282impl Term {
1283  pub fn tokens(&self) -> Vec<Token> {
1284    let mut lhs_tkns = self.lhs.tokens();
1285    let mut rhs_tkns = vec![];
1286    for (op, r) in &self.rhs {
1287      let mut tkns = r.tokens();
1288      rhs_tkns.append(&mut tkns);
1289    }
1290    lhs_tkns.append(&mut rhs_tkns);
1291    lhs_tkns
1292  }
1293}
1294
1295#[derive(Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq)]
1296pub enum Factor {
1297  Expression(Box<Expression>),
1298  Negate(Box<Factor>),
1299  Not(Box<Factor>),
1300  Parenthetical(Box<Factor>),
1301  Term(Box<Term>),
1302  Transpose(Box<Factor>),
1303}
1304
1305impl Factor {
1306  pub fn tokens(&self) -> Vec<Token> {
1307    match self {
1308      Factor::Expression(x) => x.tokens(),
1309      Factor::Negate(x) => x.tokens(),
1310      Factor::Not(x) => x.tokens(),
1311      Factor::Parenthetical(x) => x.tokens(),
1312      Factor::Term(x) => x.tokens(),
1313      Factor::Transpose(x) => x.tokens(),
1314    }
1315  }
1316}
mech_core/nodes.rs

mech_core/
nodes.rs
