Merge branch 'v0.1-beta' into 'main'

Interim merge

See merge request mech-lang/syntax!21

Author: cmontella

.gitlab-ci.yml

@@ -2,7 +2,7 @@ image: "rust:latest"
 
 test:cargo:
   script:
-  - rustup default nightly-2022-03-27
+  - rustup default nightly-2022-08-25
   - rustup show
   - rustc --version && cargo --version
   - rustup component add rust-src

Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["mech", "language", "programming", "parser", "compiler"]
 categories = ["no-std", "science::robotics", "science", "parser-implementations"]
 license = "Apache-2.0"
 readme = "README.md"
-edition = "2018"
+edition = "2021"
 
 [badges]
 gitlab = { repository = "mech-lang/syntax", branch = "main" }
@@ -23,11 +23,11 @@ no-std = ["mech-core/no-std", "rlibc"]
 [dependencies]
 mech-core = {git = "https://gitlab.com/mech-lang/core", branch = "v0.1-beta"}
 
-hashbrown = "0.12.1"
+hashbrown = "0.12.3"
 lazy_static = "1.4.0"
 nom = "7.1.1"
 nom-unicode = "0.3.0"
 unicode-segmentation = "1.9.0"
 rlibc = { version = "=1.0", optional = true }
-serde = "1.0.133"
-serde_derive = "1.0.133"
+serde = "1.0.144"
+serde_derive = "1.0.144"

README.md

@@ -2,13 +2,13 @@
   <img width="500px" src="http://mech-lang.org/img/logo.png">
 </p>
 
-Mech is a language for developing **data-driven**, **reactive** systems like animations, games, and robots. It makes **composing**, **transforming**, and **distributing** data easy, allowing you to focus on the essential complexity of your project. 
+Mech is a language for developing **data-driven**, **reactive** systems like animations, games, and robots. It makes **composing**, **transforming**, and **distributing** data easy, allowing you to focus on the essential complexity of your project.
 
 You can try Mech online at [try.mech-lang.org](http://try.mech-lang.org).
 
 Usage and installation instructions can be found in the [documentation](http://mech-lang.org/page/learn/) or the [main Mech repository](https://github.com/mech-lang/mech).
 
-Read about progress on our [blog](http://mech-lang.org/blog/), follow us on Twitter [@MechLang](https://twitter.com/MechLang), get live help on our [Gitter channel](https://gitter.im/mech-lang/community), or join the [mailing list](https://groups.google.com/forum/#!forum/mechtalk).
+Read about progress on our [blog](http://mech-lang.org/blog/), and follow us on Twitter [@MechLang](https://twitter.com/MechLang).
 
 # Mech Syntax
 

src/ast.rs

@@ -49,6 +49,11 @@ pub enum Node {
   Binding{ children: Vec<Node> },
   FunctionBinding{ children: Vec<Node> },
   Function{ name: Vec<char>, children: Vec<Node> },
+  UserFunction{ children: Vec<Node> },
+  FunctionBody{ children: Vec<Node> },
+  FunctionArgs{ children: Vec<Node> },
+  FunctionInput{ children: Vec<Node> },
+  FunctionOutput{ children: Vec<Node> },
   Define { name: Vec<char>, id: u64},
   DotIndex { children: Vec<Node>},
   Swizzle { children: Vec<Node>},
@@ -76,6 +81,7 @@ pub enum Node {
   Add,
   Subtract,
   Multiply,
+  MatrixMultiply,
   Divide,
   Exponent,
   LessThan,
@@ -112,6 +118,8 @@ pub enum Node {
   InlineMechCode{ children: Vec<Node> },
   MechCodeBlock{ children: Vec<Node> },
   Null,
+  Transpose,
+  TransposeSelect{children: Vec<Node>},
 }
 
 impl fmt::Debug for Node {
@@ -163,6 +171,12 @@ pub fn print_recurse(node: &Node, level: usize, f: &mut fmt::Formatter) {
     Node::Range => {write!(f,"Range\n").ok(); None},
     Node::Expression{children} => {write!(f,"Expression\n").ok(); Some(children)},
     Node::Function{name, children} => {write!(f,"Function({:?})\n", name).ok(); Some(children)},
+    Node::UserFunction{children} => {write!(f,"UserFunction\n").ok(); Some(children)},
+    Node::FunctionBody{children} => {write!(f,"FunctionBody\n").ok(); Some(children)},
+    Node::FunctionArgs{children} => {write!(f,"FunctionArgs\n").ok(); Some(children)},
+    Node::UserFunction{children} => {write!(f,"Expression\n").ok(); Some(children)},
+    Node::FunctionInput{children} => {write!(f,"FunctionInput\n").ok(); Some(children)},
+    Node::FunctionOutput{children} => {write!(f,"FunctionOutput\n").ok(); Some(children)},
     Node::MathExpression{children} => {write!(f,"MathExpression\n").ok(); Some(children)},
     Node::Comment{children} => {write!(f,"Comment\n").ok(); Some(children)},
     Node::SelectExpression{children} => {write!(f,"SelectExpression\n").ok(); Some(children)},
@@ -190,13 +204,16 @@ pub fn print_recurse(node: &Node, level: usize, f: &mut fmt::Formatter) {
     Node::Add => {write!(f,"Add\n").ok(); None},
     Node::Subtract => {write!(f,"Subtract\n").ok(); None},
     Node::Multiply => {write!(f,"Multiply\n").ok(); None},
+    Node::MatrixMultiply => {write!(f,"MatrixMultiply\n").ok(); None},
     Node::Divide => {write!(f,"Divide\n").ok(); None},
     Node::Exponent => {write!(f,"Exponent\n").ok(); None},
     Node::AddUpdate => {write!(f,"AddUpdate\n").ok(); None},
     Node::SubtractUpdate => {write!(f,"SubtractUpdate\n").ok(); None},
     Node::MultiplyUpdate => {write!(f,"MultiplyUpdate\n").ok(); None},
     Node::DivideUpdate => {write!(f,"DivideUpdate\n").ok(); None},
     Node::ExponentUpdate => {write!(f,"ExponentUpdate\n").ok(); None},
+    Node::Transpose => {write!(f,"Transpose\n").ok(); None},
+    Node::TransposeSelect{children} => {write!(f,"TransposeSelect\n").ok(); Some(children)},
     // Markdown Nodes
     Node::Title{text} => {write!(f,"Title({:?})\n", text).ok(); None},
     Node::ParagraphText{text} => {write!(f,"ParagraphText({:?})\n", text).ok(); None},
@@ -305,6 +322,8 @@ impl Ast {
         reversed.reverse();
         let mut select_data_children: Vec<Node> = vec![];
 
+        let mut transpose = false;
+
         for node in reversed {
           match node {
             Node::Table{name, id} => {
@@ -318,7 +337,13 @@ impl Ast {
               if select_data_children.is_empty() {
                 select_data_children = vec![Node::Null; 1];
               }
-              compiled.push(Node::SelectData{name, id: TableId::Local(id), children: select_data_children.clone()});
+              select_data_children.reverse();
+              let select = Node::SelectData{name, id: TableId::Local(id), children: select_data_children.clone()};
+              if transpose {
+                compiled.push(Node::TransposeSelect{children: vec![select]});
+              } else {
+                compiled.push(select);
+              }
             },
             Node::DotIndex{children} => {
               let mut reversed = children.clone();
@@ -337,6 +362,9 @@ impl Ast {
             Node::ReshapeColumn => {
               select_data_children.push(Node::ReshapeColumn);
             }
+            Node::Transpose => {
+              transpose = true;
+            }
             _ => (),
           }
         }
@@ -796,6 +824,7 @@ impl Ast {
           Node::Add => "math/add".chars().collect(),
           Node::Subtract => "math/subtract".chars().collect(),
           Node::Multiply => "math/multiply".chars().collect(),
+          Node::MatrixMultiply => "matrix/multiply".chars().collect(),
           Node::Divide => "math/divide".chars().collect(),
           Node::Exponent => "math/exponent".chars().collect(),
           Node::GreaterThan => "compare/greater-than".chars().collect(),
@@ -821,6 +850,26 @@ impl Ast {
         let result = self.compile_nodes(children);
         compiled.push(Node::Function{name: "math/negate".chars().collect(), children: result});
       },
+      parser::Node::UserFunction{children} => {
+        let result = self.compile_nodes(children);
+        compiled.push(Node::UserFunction{children: result.clone()});
+      }
+      parser::Node::FunctionArgs{children} => {
+        let result = self.compile_nodes(children);
+        compiled.push(Node::FunctionArgs{children: result.clone()});
+      }
+      parser::Node::FunctionInput{children} => {
+        let result = self.compile_nodes(children);
+        compiled.push(Node::FunctionInput{children: result.clone()});
+      }
+      parser::Node::FunctionOutput{children} => {
+        let result = self.compile_nodes(children);
+        compiled.push(Node::FunctionOutput{children: result.clone()});
+      }
+      parser::Node::FunctionBody{children} => {
+        let result = self.compile_nodes(children);
+        compiled.push(Node::FunctionBody{children: result.clone()});
+      }
       parser::Node::Function{children} => {
         let result = self.compile_nodes(children);
         let mut children: Vec<Node> = Vec::new();
@@ -873,6 +922,9 @@ impl Ast {
       parser::Node::True => {
         compiled.push(Node::True);
       },
+      parser::Node::Transpose => {
+        compiled.push(Node::Transpose);
+      },
       parser::Node::False => {
         compiled.push(Node::False);
       },
@@ -934,6 +986,7 @@ impl Ast {
       parser::Node::Add => compiled.push(Node::Add),
       parser::Node::Subtract => compiled.push(Node::Subtract),
       parser::Node::Multiply => compiled.push(Node::Multiply),
+      parser::Node::MatrixMultiply => compiled.push(Node::MatrixMultiply),
       parser::Node::Divide => compiled.push(Node::Divide),
       parser::Node::Exponent => compiled.push(Node::Exponent),
       parser::Node::And => compiled.push(Node::And),

src/bin/main.rs

@@ -9,11 +9,10 @@ use std::rc::Rc;
 fn main() -> Result<(),MechError> {
 
 let input = r#"
-block
-  #y = [[1;2];[3]]
-block
-  x -< #y
-  #test = stats/sum(column: x)"#;
+x = [1 2 3]
+y = [4 5; 6 7; 8 9]
+z = x ** y
+#test = stats/sum(row: z)"#;
   let input = String::from(input);
 
   let mut ast = Ast::new();
@@ -26,9 +25,9 @@ block
 
   println!("{:?}", ast.syntax_tree);
 
-  let blocks = compiler.compile_blocks(&vec![ast.syntax_tree.clone()]).unwrap();
+  let sections = compiler.compile_sections(&vec![ast.syntax_tree.clone()]).unwrap();
 
-  core.load_blocks(blocks);
+  core.load_sections(sections);
   println!("{:#?}", core.blocks);
   println!("{:?}", core);
 
@@ -78,14 +77,14 @@ block
     ];
     core.process_transaction(&txn)?;
     println!("{:#?}", core.get_table("balls").unwrap().borrow());
-  }
-  let txn: Vec<Change> = vec![
-    Change::Set((hash_str("time/timer"), vec![(TableIndex::Index(1), TableIndex::Alias(hash_str("ticks")), Value::U64(U64::new(1)))])),
-    Change::Set((hash_str("time/timer"), vec![(TableIndex::Index(1), TableIndex::Alias(hash_str("ticks")), Value::U64(U64::new(2)))])),
-  ];
-  println!("Processing Txn...");
-  core.process_transaction(&txn);
-  println!("Done Txn.");*/
+  }*/
+  //let txn: Vec<Change> = vec![
+    //Change::Set((hash_str("time/timer"), vec![(TableIndex::Index(1), TableIndex::Alias(hash_str("ticks")), Value::U64(U64::new(1)))])),
+    //Change::Set((hash_str("time/timer"), vec![(TableIndex::Index(1), TableIndex::Alias(hash_str("ticks")), Value::U64(U64::new(2)))])),
+  //];
+  //println!("Processing Txn...");
+  //core.process_transaction(&txn);
+  //println!("Done Txn.");
   //println!("{:#?}", core.blocks);
 
   //println!("Core:");