Improved tuple parsing

src/parser/stage/groupify.rs

@@ -209,6 +209,13 @@ pub fn groupify(
 	let mut levels: Vec<(LineLocation, VecDeque<Token>)> = Vec::with_capacity(8);
 	levels.push((LineLocation{pos: 0, len: last_linelocation.pos + last_linelocation.len}, VecDeque::with_capacity(8)));
 
+	// Group types
+	// if true, this is a tuple.
+	// if false, this is a group.
+	let mut is_tuple: Vec<bool> = Vec::with_capacity(8);
+	is_tuple.push(false);
+
+
 	// Makes sure parenthesis are matched
 	let mut i_level = 0;
 
@@ -219,6 +226,7 @@ pub fn groupify(
 		match t {
 			Token::GroupStart(l) => {
 				levels.push((l, VecDeque::with_capacity(8)));
+				is_tuple.push(false);
 				i_level += 1;
 			},
 
@@ -234,14 +242,23 @@ pub fn groupify(
 				let (_, v_now) = levels.last_mut().unwrap();
 				lookback(&mut v, context)?;
 
-				v_now.push_back(Token::Group(l, v));
+				let q = is_tuple.pop().unwrap();
+				if q {
+					v_now.push_back(Token::new_tuple(l, v)?);
+				} else {
+					v_now.push_back(Token::Group(l, v));
+				}
+			},
+
+			Token::TupleDelim(_) => {
+				*is_tuple.last_mut().unwrap() = true;
+				v_now.push_back(t);
 			},
 
 			_ => {
 				v_now.push_back(t);
 			}
 		}
-
 	}
 
 	/*
@@ -260,12 +277,27 @@ pub fn groupify(
 		if v.len() == 0 { return Err((l, DaisyError::EmptyGroup)) }
 		lookback(&mut v, context)?;
 
-		v_now.push_back(Token::Group(l, v));
+		let q = is_tuple.pop().unwrap();
+		if q {
+			v_now.push_back(Token::new_tuple(l, v)?);
+		} else {
+			v_now.push_back(Token::Group(l, v));
+		}
 	}
 
 
-	let (_, mut v) = levels.pop().unwrap();
+
+	let (l, mut v) = levels.pop().unwrap();
+	let q = is_tuple.pop().unwrap();
+
+	if q {
+		return Err((l, DaisyError::BadTuple));
+	}
+
 	lookback(&mut v, context)?;
 
-	return Ok(Token::Group(LineLocation{pos:0, len:last_linelocation.pos + last_linelocation.len}, v));
+	return Ok(Token::Group(
+		LineLocation{pos:0, len:last_linelocation.pos + last_linelocation.len},
+		v
+	));
 }

src/parser/stage/tokenize.rs

@@ -20,7 +20,8 @@ fn push_token(
 	let mut t = t.unwrap();
 
 	match t {
-		Token::GroupStart(ref mut l)
+		Token::TupleDelim(ref mut l)
+		| Token::GroupStart(ref mut l)
 		| Token::GroupEnd(ref mut l)
 		| Token::Operator(ref mut l, _)
 		| Token::Quantity(ref mut l, _)
@@ -33,6 +34,7 @@ fn push_token(
 		},
 
 		Token::Group(_,_)
+		| Token::Tuple(_,_)
 		| Token::Container(_)
 		=> unreachable!()
 	};
@@ -143,10 +145,7 @@ pub fn tokenize(input: &String, context: &Context) -> VecDeque<Token> {
 
 			',' => {
 				push_token(&mut g, t, i, context);
-				t = Some(Token::Operator(
-					LineLocation{pos: i, len: 1},
-					String::from(c)
-				));
+				t = Some(Token::TupleDelim(LineLocation{pos: i, len: 1}));
 			},
 
 			// Operator

src/parser/stage/treeify.rs

@@ -124,6 +124,9 @@ fn treeify_binary(
 		if let Token::Group(l, _) = right_pre {
 			right = treeify(right_pre, context)?;
 			right.set_linelocation(&(right.get_linelocation() + l));
+		} else if let Token::Tuple(l, _) = right_pre {
+			right = treeify(right_pre, context)?;
+			right.set_linelocation(&(right.get_linelocation() + l));
 		} else {
 			right = right_pre.to_expression(context)?;
 		}
@@ -131,6 +134,9 @@ fn treeify_binary(
 		if let Token::Group(l, _) = left_pre {
 			left = treeify(left_pre, context)?;
 			left.set_linelocation(&(left.get_linelocation() + l));
+		} else if let Token::Tuple(l, _) = left_pre {
+			left = treeify(left_pre, context)?;
+			left.set_linelocation(&(left.get_linelocation() + l));
 		} else {
 			left = left_pre.to_expression(context)?;
 		}
@@ -251,6 +257,9 @@ fn treeify_unary(
 			if let Token::Group(l, _) = next_pre {
 				next = treeify(next_pre, context)?;
 				next.set_linelocation(&(next.get_linelocation() + l));
+			} else if let Token::Tuple(l, _) = next_pre {
+				next = treeify(next_pre, context)?;
+				next.set_linelocation(&(next.get_linelocation() + l));
 			} else {
 				next = next_pre.to_expression(context)?;
 			}
@@ -286,8 +295,17 @@ pub fn treeify(
 	mut g: Token,
 	context: &Context
 ) -> Result<Expression, (LineLocation, DaisyError)> {
+
 	let (l, g_inner): (LineLocation, &mut VecDeque<Token>) = match g {
 		Token::Group(l, ref mut x) => (l, x),
+		Token::Tuple(l, parts) => {
+			let mut t: VecDeque<Expression> = VecDeque::new();
+			for p in parts {
+				t.push_back(treeify(p, context)?);
+			};
+
+			return Ok(Expression::Tuple(l, t));
+		},
 		_ => panic!()
 	};
 
@@ -358,10 +376,12 @@ pub fn treeify(
 		Token::Operator(l, _) => {
 			Err((l, DaisyError::Syntax))
 		},
+		Token::Tuple(_, _) |
 		Token::Group(_,_) => {
 			treeify(g, context)
 		},
 
+
 		_ => { Ok(g.to_expression(context)?) }
 	};
 }