Add vector parsing

src/elements/group.rs

@@ -13,6 +13,7 @@ pub enum Group {
     Ceil(Ceil),
     Norm(Norm),
     Matrix(Matrix),
+    Vector(Vector),
 }
 
 #[derive(Debug, Clone, PartialOrd, PartialEq)]
@@ -64,3 +65,8 @@ pub struct Norm {
 pub struct Matrix {
     pub inner: Vec<Vec<Expression>>,
 }
+
+#[derive(Debug, Clone, PartialOrd, PartialEq)]
+pub struct Vector {
+    pub inner: Vec<Expression>,
+}

src/lib.rs

@@ -28,7 +28,7 @@ pub fn parse(content: String) -> Expression {
 
 #[cfg(test)]
 mod tests {
-    use crate::elements::group::{Brackets, Group, Matrix};
+    use crate::elements::group::{Brackets, Group, Matrix, Vector};
     use crate::elements::literal::{Literal, Number};
     use crate::elements::special::{Expression, Special, Sum};
     use crate::elements::Element;
@@ -275,12 +275,37 @@ mod tests {
     }
 
     #[test]
+    fn it_parses_vectors() {
+        assert_eq!(
+            parse("((1), (2))".to_string()),
+            Expression {
+                children: vec![Element::Group(Group::Vector(Vector {
+                    inner: vec![
+                        Expression {
+                            children: vec![Element::Literal(Literal::Number(Number {
+                                number: "1".to_string()
+                            }))]
+                        },
+                        Expression {
+                            children: vec![Element::Literal(Literal::Number(Number {
+                                number: "2".to_string()
+                            }))]
+                        }
+                    ]
+                }))]
+            }
+        )
+    }
+
+    //#[test]
     fn it_parses_into_a_tree3() {
         fs::write(
             "test-files/test.txt",
             format!(
                 "{:#?}",
-                parse("color(red)(a) * b^4 - c(c-2) [[1, 3, 2 + 2],[3 - x, 4]".to_string())
+                parse(
+                    "color(red)(a) * b^4 - c(c-2) [[1, 3, 2 + 2],[3 - x, 4] ((2),(3))".to_string()
+                )
             ),
         );
     }

src/parsing/tree_parser.rs

@@ -1,6 +1,6 @@
 use crate::elements::accent::{Color, ExpressionAccent, GenericAccent, OverSet, UnderSet};
 use crate::elements::group::{
-    Abs, Angles, Braces, Brackets, Ceil, Floor, Group, Matrix, Norm, Parentheses, XGroup,
+    Abs, Angles, Braces, Brackets, Ceil, Floor, Group, Matrix, Norm, Parentheses, Vector, XGroup,
 };
 use crate::elements::literal::{Literal, Number, PlainText, Symbol};
 use crate::elements::special::{
@@ -104,6 +104,8 @@ impl TreeParser {
             Token::Grouping(g) => {
                 if let Some(group) = self.parse_matrix() {
                     Some(Element::Group(group))
+                } else if let Some(group) = self.parse_vector() {
+                    Some(Element::Group(group))
                 } else if let Some(group) = self.parse_group(g) {
                     Some(Element::Group(group))
                 } else {
@@ -259,6 +261,7 @@ impl TreeParser {
     fn parse_matrix(&mut self) -> Option<Group> {
         let token = self.current_token().clone();
         let start_index = self.index;
+
         if let Token::Grouping(Grouping::RBracket) = token {
             let mut expressions = Vec::new();
 
@@ -296,7 +299,7 @@ impl TreeParser {
                 .collect::<Vec<Vec<Expression>>>();
 
             // a matrix with no elements is invalid
-            if expression_matrix.len() == 0 {
+            if expression_matrix.is_empty() {
                 self.index = start_index;
                 return None;
             }
@@ -304,12 +307,46 @@ impl TreeParser {
             let first_length = expression_matrix.first().unwrap().len();
             if !expression_matrix.iter().all(|e| e.len() == first_length) {
                 self.index = start_index;
-                return None;
+                None
+            } else {
+                Some(Group::Matrix(Matrix {
+                    inner: expression_matrix,
+                }))
             }
+        } else {
+            None
+        }
+    }
 
-            Some(Group::Matrix(Matrix {
-                inner: expression_matrix,
-            }))
+    fn parse_vector(&mut self) -> Option<Group> {
+        let token = self.current_token().clone();
+        let start_index = self.index;
+
+        if let Token::Grouping(Grouping::RParen) = token {
+            let mut expressions = Vec::new();
+
+            while !self.end_reached() {
+                if let Some(Token::Grouping(Grouping::RParen)) = self.peek() {
+                    self.step();
+                    self.step();
+                    expressions.push(self.parse_expression());
+
+                    if let Token::Grouping(Grouping::LParen) = self.current_token() {
+                        self.step();
+                    }
+                    if let Token::Grouping(Grouping::LParen) = self.current_token() {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            if expressions.is_empty() {
+                self.index = start_index;
+                None
+            } else {
+                Some(Group::Vector(Vector { inner: expressions }))
+            }
         } else {
             None
         }