Implemented arrays

14 files changed, 548 insertions, 60 deletions

diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java
index a6d5c75..fb4b086 100644
--- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java
+++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java
@@ -7,6 +7,7 @@ import bjc.dicelang.ast.DiceASTInliner;
 import bjc.dicelang.ast.DiceASTOptimizer;
 import bjc.dicelang.ast.DiceASTParser;
 import bjc.dicelang.ast.DiceASTReferenceSanitizer;
+import bjc.dicelang.ast.IResult;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.optimization.ConstantCollapser;
 import bjc.dicelang.ast.optimization.OperationCondenser;
@@ -114,7 +115,7 @@ public class DiceASTLanguageTest {
 
 			IFunctionalList<String> preparedTokens =
 					DiceExpressionPreparer.prepareCommand(currentLine);
-
+			
 			try {
 				builtAST = DiceASTParser.createFromString(preparedTokens);
 			} catch (IllegalStateException isex) {
@@ -125,11 +126,17 @@ public class DiceASTLanguageTest {
 				continue;
 			}
 
-			int sampleRoll;
+			// Print out results
+			System.out.println("\tParsed: " + builtAST.toString());
 
 			ITree<IDiceASTNode> transformedAST =
 					transformAST(builtAST, enviroment);
 
+			System.out
+					.println("\tEvaluated: " + transformedAST.toString());
+
+			IResult sampleRoll;
+
 			try {
 				sampleRoll = DiceASTEvaluator.evaluateAST(transformedAST,
 						enviroment);
@@ -143,10 +150,6 @@ public class DiceASTLanguageTest {
 				continue;
 			}
 
-			// Print out results
-			System.out.println("\tParsed: " + builtAST.toString());
-			System.out
-					.println("\tEvaluated: " + transformedAST.toString());
 			System.out.println("\t\tSample Roll: " + sampleRoll);
 
 			// Increase the number of commands
@@ -173,7 +176,11 @@ public class DiceASTLanguageTest {
 		ITree<IDiceASTNode> sanitizedTree = DiceASTReferenceSanitizer
 				.sanitize(condensedTree, enviroment);
 
-		return sanitizedTree;
+		optimizedTree = optimizer.optimizeTree(sanitizedTree, enviroment);
+
+		condensedTree = OperationCondenser.condense(optimizedTree);
+
+		return condensedTree;
 	}
 
 	private static String getNextCommand(Scanner inputSource,
diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java
index caf7f37..4524fa0 100644
--- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java
+++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java
@@ -67,6 +67,8 @@ public class DiceExpressionPreparer {
 
 		ops.add(new Pair<>("(", "\\("));
 		ops.add(new Pair<>(")", "\\)"));
+		ops.add(new Pair<>("[", "\\["));
+		ops.add(new Pair<>("]", "\\]"));
 
 		IFunctionalList<String> fullyExpandedTokens =
 				ListUtils.deAffixTokens(semiExpandedTokens, ops);
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java
index 5c00fe2..ad508c8 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java
@@ -28,12 +28,12 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 	}
 
 	@Override
-	public IPair<Integer, ITree<IDiceASTNode>> apply(
-			IFunctionalList<IPair<Integer, ITree<IDiceASTNode>>> nodes) {
-		IPair<Integer, ITree<IDiceASTNode>> initState =
-				new Pair<>(0, new Tree<>(type));
+	public IPair<IResult, ITree<IDiceASTNode>> apply(
+			IFunctionalList<IPair<IResult, ITree<IDiceASTNode>>> nodes) {
+		IPair<IResult, ITree<IDiceASTNode>> initState =
+				new Pair<>(new IntegerResult(0), new Tree<>(type));
 
-		BinaryOperator<IPair<Integer, ITree<IDiceASTNode>>> reducer =
+		BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer =
 				(currentState, accumulatedState) -> {
 					// Force evaluation of accumulated state to prevent
 					// certain bugs from occuring
@@ -42,27 +42,133 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 					return reduceStates(accumulatedState, currentState);
 				};
 
-		IPair<Integer, ITree<IDiceASTNode>> reducedState =
+		IPair<IResult, ITree<IDiceASTNode>> reducedState =
 				nodes.reduceAux(initState, reducer, (state) -> state);
 
 		return reducedState;
 	}
 
-	private IPair<Integer, ITree<IDiceASTNode>> reduceStates(
-			IPair<Integer, ITree<IDiceASTNode>> accumulatedState,
-			IPair<Integer, ITree<IDiceASTNode>> currentState) {
+	private IPair<IResult, ITree<IDiceASTNode>> reduceStates(
+			IPair<IResult, ITree<IDiceASTNode>> accumulatedState,
+			IPair<IResult, ITree<IDiceASTNode>> currentState) {
 		return accumulatedState
 				.bind((accumulatedValue, accumulatedTree) -> {
 					return currentState
 							.bind((currentValue, currentTree) -> {
 								accumulatedTree.addChild(currentTree);
 
-								Integer combinedValue = valueOp.apply(
-										accumulatedValue, currentValue);
-
-								return new Pair<>(combinedValue,
-										accumulatedTree);
+								return doArithmeticCollapse(
+										accumulatedValue, accumulatedTree,
+										currentValue);
 							});
 				});
 	}
+
+	private IPair<IResult, ITree<IDiceASTNode>> doArithmeticCollapse(
+			IResult accumulatedValue, ITree<IDiceASTNode> accumulatedTree,
+			IResult currentValue) {
+		boolean currentIsInt =
+				currentValue.getType() == ResultType.INTEGER;
+		boolean accumulatedIsInt =
+				accumulatedValue.getType() == ResultType.INTEGER;
+
+		if (!currentIsInt) {
+			if (!accumulatedIsInt) {
+				IFunctionalList<IResult> resultList = combineArrayResults(
+						accumulatedValue, currentValue);
+
+				return new Pair<>(new ArrayResult(resultList),
+						accumulatedTree);
+			}
+
+			IFunctionalList<IResult> resultList = halfCombineLists(
+					((ArrayResult) currentValue).getValue(),
+					accumulatedValue, true);
+
+			return new Pair<>(new ArrayResult(resultList),
+					accumulatedTree);
+		} else if (!accumulatedIsInt) {
+			IFunctionalList<IResult> resultList = halfCombineLists(
+					((ArrayResult) accumulatedValue).getValue(),
+					currentValue, false);
+
+			return new Pair<>(new ArrayResult(resultList),
+					accumulatedTree);
+		}
+
+		int accumulatedInt = ((IntegerResult) accumulatedValue).getValue();
+		int currentInt = ((IntegerResult) currentValue).getValue();
+
+		int combinedValue = valueOp.apply(accumulatedInt, currentInt);
+
+		return new Pair<>(new IntegerResult(combinedValue),
+				accumulatedTree);
+	}
+
+	private IFunctionalList<IResult> combineArrayResults(
+			IResult accumulatedValue, IResult currentValue) {
+		IFunctionalList<IResult> currentList =
+				((ArrayResult) currentValue).getValue();
+		IFunctionalList<IResult> accumulatedList =
+				((ArrayResult) accumulatedValue).getValue();
+
+		if (currentList.getSize() != accumulatedList.getSize()) {
+			throw new UnsupportedOperationException(
+					"Can only apply operations to equal-length arrays");
+		}
+
+		IFunctionalList<IResult> resultList = currentList.combineWith(
+				accumulatedList, (currentNode, accumulatedNode) -> {
+					boolean currentNotInt =
+							currentNode.getType() != ResultType.INTEGER;
+					boolean accumulatedNotInt = accumulatedNode
+							.getType() != ResultType.INTEGER;
+
+					if (currentNotInt || accumulatedNotInt) {
+						throw new UnsupportedOperationException(
+								"Nesting of array operations isn't allowed");
+					}
+
+					int accumulatedInt =
+							((IntegerResult) accumulatedNode).getValue();
+					int currentInt =
+							((IntegerResult) currentNode).getValue();
+
+					IResult combinedValue = new IntegerResult(
+							valueOp.apply(accumulatedInt, currentInt));
+					return combinedValue;
+				});
+		return resultList;
+	}
+
+	private IFunctionalList<IResult> halfCombineLists(
+			IFunctionalList<IResult> list, IResult scalar,
+			boolean scalarLeft) {
+		if (scalar.getType() != ResultType.INTEGER) {
+			throw new UnsupportedOperationException(
+					"Nested array operations not supported");
+		}
+
+		int scalarInt = ((IntegerResult) scalar).getValue();
+
+		return list.map((element) -> {
+			if (element.getType() != ResultType.INTEGER) {
+				throw new UnsupportedOperationException(
+						"Nested array operations not supported");
+			}
+			int elementInt = ((IntegerResult) element).getValue();
+
+			IResult combinedValue;
+
+			if (scalarLeft) {
+				combinedValue = new IntegerResult(
+						valueOp.apply(scalarInt, elementInt));
+			} else {
+				combinedValue = new IntegerResult(
+						valueOp.apply(elementInt, scalarInt));
+			}
+
+			return combinedValue;
+		});
+	}
 }
\ No newline at end of file
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/ArrayResult.java b/dice-lang/src/main/java/bjc/dicelang/ast/ArrayResult.java
new file mode 100644
index 0000000..1bd0940
--- /dev/null
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/ArrayResult.java
@@ -0,0 +1,43 @@
+package bjc.dicelang.ast;
+
+import bjc.utils.funcdata.IFunctionalList;
+
+/**
+ * Represents a result that is an array of other results
+ * 
+ * @author ben
+ *
+ *         TODO finish implementing me
+ */
+public class ArrayResult implements IResult {
+	private IFunctionalList<IResult> arrayContents;
+
+	/**
+	 * Create a new array-valued result
+	 * 
+	 * @param results
+	 *            The results in the array
+	 */
+	public ArrayResult(IFunctionalList<IResult> results) {
+		this.arrayContents = results;
+	}
+
+	@Override
+	public ResultType getType() {
+		return ResultType.ARRAY;
+	}
+
+	/**
+	 * Get the value of this result
+	 * 
+	 * @return The value of this result
+	 */
+	public IFunctionalList<IResult> getValue() {
+		return arrayContents;
+	}
+
+	@Override
+	public String toString() {
+		return arrayContents.toString();
+	}
+}
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
index aeecb38..7d073d4 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
@@ -1,6 +1,7 @@
 package bjc.dicelang.ast;
 
 import bjc.dicelang.ComplexDice;
+import bjc.dicelang.ast.nodes.DiceASTType;
 import bjc.dicelang.ast.nodes.DiceLiteralNode;
 import bjc.dicelang.ast.nodes.DiceLiteralType;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
@@ -8,9 +9,12 @@ import bjc.dicelang.ast.nodes.ILiteralDiceNode;
 import bjc.dicelang.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.ast.nodes.OperatorDiceNode;
 import bjc.dicelang.ast.nodes.VariableDiceNode;
+import bjc.utils.data.IHolder;
 import bjc.utils.data.IPair;
+import bjc.utils.data.Identity;
 import bjc.utils.data.LazyPair;
 import bjc.utils.data.Pair;
+import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.FunctionalMap;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.IFunctionalMap;
@@ -71,12 +75,27 @@ public class DiceASTEvaluator {
 			return parseLet(enviroment, nodes);
 		});
 
+		operatorCollapsers.put(OperatorDiceNode.ARRAY, (nodes) -> {
+			ITree<IDiceASTNode> returnedTree =
+					new Tree<>(OperatorDiceNode.ARRAY);
+			IFunctionalList<IResult> resultList = new FunctionalList<>();
+
+			nodes.forEach((element) -> {
+				element.doWith((result, tree) -> {
+					resultList.add(result);
+					returnedTree.addChild(tree);
+				});
+			});
+
+			return new Pair<>(new ArrayResult(resultList), returnedTree);
+		});
+
 		return operatorCollapsers;
 	}
 
-	private static IPair<Integer, ITree<IDiceASTNode>> parseLet(
+	private static IPair<IResult, ITree<IDiceASTNode>> parseLet(
 			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment,
-			IFunctionalList<IPair<Integer, ITree<IDiceASTNode>>> nodes) {
+			IFunctionalList<IPair<IResult, ITree<IDiceASTNode>>> nodes) {
 		if (nodes.getSize() != 2) {
 			throw new UnsupportedOperationException(
 					"Can only use let with two expressions.");
@@ -90,7 +109,7 @@ public class DiceASTEvaluator {
 				enviroment.extend();
 
 		evaluateAST(bindTree, letEnviroment);
-		int exprResult = evaluateAST(expressionTree, letEnviroment);
+		IResult exprResult = evaluateAST(expressionTree, letEnviroment);
 
 		IFunctionalList<ITree<IDiceASTNode>> childrn =
 				nodes.map((pair) -> pair.getRight());
@@ -108,7 +127,7 @@ public class DiceASTEvaluator {
 	 *            The enviroment to look up variables in
 	 * @return The integer value of the expression
 	 */
-	public static int evaluateAST(ITree<IDiceASTNode> expression,
+	public static IResult evaluateAST(ITree<IDiceASTNode> expression,
 			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment) {
 		IFunctionalMap<IDiceASTNode, IOperatorCollapser> collapsers =
 				buildOperations(enviroment);
@@ -118,7 +137,7 @@ public class DiceASTEvaluator {
 				(pair) -> pair.getLeft());
 	}
 
-	private static IPair<Integer, ITree<IDiceASTNode>> evaluateLeaf(
+	private static IPair<IResult, ITree<IDiceASTNode>> evaluateLeaf(
 			IDiceASTNode leafNode,
 			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment) {
 		ITree<IDiceASTNode> returnedAST = new Tree<>(leafNode);
@@ -139,31 +158,35 @@ public class DiceASTEvaluator {
 		}
 	}
 
-	private static Integer bindLiteralValue(IDiceASTNode leafNode,
+	private static IResult bindLiteralValue(IDiceASTNode leafNode,
 			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment) {
 		String variableName = ((VariableDiceNode) leafNode).getVariable();
 
 		if (enviroment.containsKey(variableName)) {
-			int result =
+			IResult result =
 					evaluateAST(enviroment.get(variableName), enviroment);
 
 			return result;
 		}
 
-		throw new UnsupportedOperationException(
-				"Attempted to dereference unbound variable "
-						+ variableName);
+		// Allow for array assignment easily
+		return new IntegerResult(0);
 	}
 
-	private static int evaluateLiteral(IDiceASTNode leafNode) {
+	private static IResult evaluateLiteral(IDiceASTNode leafNode) {
 		DiceLiteralType literalType =
 				((ILiteralDiceNode) leafNode).getLiteralType();
 
 		switch (literalType) {
 			case DICE:
-				return ((DiceLiteralNode) leafNode).getValue().roll();
+				int diceRoll =
+						((DiceLiteralNode) leafNode).getValue().roll();
+
+				return new IntegerResult(diceRoll);
 			case INTEGER:
-				return ((IntegerLiteralNode) leafNode).getValue();
+				int val = ((IntegerLiteralNode) leafNode).getValue();
+
+				return new IntegerResult(val);
 			default:
 				throw new UnsupportedOperationException("Literal value '"
 						+ leafNode + "' is of a type (" + literalType
@@ -171,22 +194,19 @@ public class DiceASTEvaluator {
 		}
 	}
 
-	private static IPair<Integer, ITree<IDiceASTNode>> parseBinding(
+	private static IPair<IResult, ITree<IDiceASTNode>> parseBinding(
 			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment,
-			IFunctionalList<IPair<Integer, ITree<IDiceASTNode>>> nodes) {
+			IFunctionalList<IPair<IResult, ITree<IDiceASTNode>>> nodes) {
 		if (nodes.getSize() != 2) {
 			throw new UnsupportedOperationException(
 					"Can only bind nodes with two children. Problem children are "
 							+ nodes);
 		}
 
-		IPair<Integer, ITree<IDiceASTNode>> nameNode = nodes.getByIndex(0);
-		IPair<Integer, ITree<IDiceASTNode>> valueNode =
+		IPair<IResult, ITree<IDiceASTNode>> nameNode = nodes.getByIndex(0);
+		IPair<IResult, ITree<IDiceASTNode>> valueNode =
 				nodes.getByIndex(1);
 
-		// Force valueNode to materialize for debugging purposes
-		valueNode.merge((l, r) -> null);
-
 		return nameNode.bindRight((nameTree) -> {
 			return valueNode.bind((valueValue, valueTree) -> {
 				if (DiceASTUtils.containsSimpleVariable(nameTree)) {
@@ -197,6 +217,36 @@ public class DiceASTEvaluator {
 					enviroment.put(varName, valueTree);
 
 					return new Pair<>(valueValue, nameTree);
+				} else if (nameTree.getHead() == OperatorDiceNode.ARRAY) {
+					if (valueTree.getHead() == OperatorDiceNode.ARRAY) {
+						if (nameTree.getChildrenCount() != valueTree
+								.getChildrenCount()) {
+							throw new UnsupportedOperationException(
+									"Array assignment must be between two equal length arrays");
+						}
+
+						IHolder<Integer> childCount = new Identity<>(0);
+
+						nameTree.doForChildren((child) -> {
+							doArrayAssign(enviroment, nameNode, nameTree,
+									valueTree, childCount, child);
+
+							childCount.transform(val -> val + 1);
+						});
+
+						return new Pair<>(valueValue, nameTree);
+					}
+
+					nameTree.doForChildren((child) -> {
+						String varName = child.transformHead((nameNod) -> {
+							return ((VariableDiceNode) nameNod)
+									.getVariable();
+						});
+
+						enviroment.put(varName, valueTree);
+					});
+
+					return new Pair<>(valueValue, nameTree);
 				}
 
 				throw new UnsupportedOperationException(
@@ -206,24 +256,45 @@ public class DiceASTEvaluator {
 		});
 	}
 
-	private static IPair<Integer, ITree<IDiceASTNode>> parseGroup(
-			IFunctionalList<IPair<Integer, ITree<IDiceASTNode>>> nodes) {
+	private static void doArrayAssign(
+			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment,
+			IPair<IResult, ITree<IDiceASTNode>> nameNode,
+			ITree<IDiceASTNode> nameTree, ITree<IDiceASTNode> valueTree,
+			IHolder<Integer> childCount, ITree<IDiceASTNode> child) {
+		if (nameTree.getHead().getType() != DiceASTType.VARIABLE) {
+			throw new UnsupportedOperationException(
+					"Assigning to complex variables isn't supported. Problem node is "
+							+ nameNode.getRight());
+		}
+
+		String varName = child.transformHead((nameNod) -> {
+			return ((VariableDiceNode) nameNod).getVariable();
+		});
+
+		enviroment.put(varName, valueTree.getChild(childCount.getValue()));
+
+		childCount.transform(val -> val + 1);
+	}
+
+	private static IPair<IResult, ITree<IDiceASTNode>> parseGroup(
+			IFunctionalList<IPair<IResult, ITree<IDiceASTNode>>> nodes) {
 		if (nodes.getSize() != 2) {
 			throw new UnsupportedOperationException(
 					"Can only form a group from two dice");
 		}
 
-		IPair<Integer, ITree<IDiceASTNode>> numberDiceNode =
+		IPair<IResult, ITree<IDiceASTNode>> numberDiceNode =
 				nodes.getByIndex(0);
-		IPair<Integer, ITree<IDiceASTNode>> diceTypeNode =
+		IPair<IResult, ITree<IDiceASTNode>> diceTypeNode =
 				nodes.getByIndex(1);
 
 		return numberDiceNode.bind((numberDiceValue, numberDiceTree) -> {
 			return diceTypeNode.bind((diceTypeValue, diceTypeTree) -> {
-				ComplexDice cDice =
-						new ComplexDice(numberDiceValue, diceTypeValue);
+				ComplexDice cDice = new ComplexDice(
+						((IntegerResult) numberDiceValue).getValue(),
+						((IntegerResult) diceTypeValue).getValue());
 
-				return new Pair<>(cDice.roll(),
+				return new Pair<>(new IntegerResult(cDice.roll()),
 						new Tree<>(OperatorDiceNode.GROUP, numberDiceTree,
 								diceTypeTree));
 			});
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java
index d8c94dc..c746c8b 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java
@@ -1,6 +1,9 @@
 package bjc.dicelang.ast;
 
+import java.util.Deque;
 import java.util.InputMismatchException;
+import java.util.function.Function;
+import java.util.function.Predicate;
 
 import bjc.dicelang.IDiceExpression;
 import bjc.dicelang.ast.nodes.DiceLiteralNode;
@@ -10,8 +13,13 @@ import bjc.dicelang.ast.nodes.ILiteralDiceNode;
 import bjc.dicelang.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.ast.nodes.OperatorDiceNode;
 import bjc.dicelang.ast.nodes.VariableDiceNode;
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
 import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcdata.ITree;
+import bjc.utils.funcdata.Tree;
+import bjc.utils.funcutils.StringUtils;
 import bjc.utils.parserutils.TreeConstructor;
 
 /**
@@ -30,22 +38,77 @@ public class DiceASTParser {
 	 */
 	public static ITree<IDiceASTNode>
 			createFromString(IFunctionalList<String> tokens) {
+		Predicate<String> specialPicker = (operator) -> {
+			if (StringUtils.containsOnly(operator, "\\[")) {
+				return true;
+			} else if (StringUtils.containsOnly(operator, "\\]")) {
+				return true;
+			}
+
+			return false;
+		};
+
+		IFunctionalMap<String, Function<Deque<ITree<String>>, ITree<String>>> operators =
+				new FunctionalMap<>();
+
+		operators.put("[", (queuedTrees) -> {
+			Tree<String> openTree = new Tree<>("[");
+
+			return openTree;
+		});
+
+		operators.put("]", (queuedTrees) -> {
+			return parseCloseArray(queuedTrees);
+		});
+
 		ITree<String> rawTokens =
 				TreeConstructor.constructTree(tokens, (token) -> {
 					return isOperatorNode(token);
-				}, (operator) -> false, null);
-
-		// The last argument is valid because there are no special
-		// operators yet, so it'll never get called
+				}, specialPicker, operators::get);
 
 		ITree<IDiceASTNode> tokenizedTree =
 				rawTokens.rebuildTree(DiceASTParser::convertLeafNode,
 						DiceASTParser::convertOperatorNode);
-		
+
 		return tokenizedTree;
 	}
 
+	private static ITree<String>
+			parseCloseArray(Deque<ITree<String>> queuedTrees) {
+		IFunctionalList<ITree<String>> children = new FunctionalList<>();
+
+		while (shouldContinuePopping(queuedTrees)) {
+			children.add(queuedTrees.pop());
+		}
+		
+		queuedTrees.pop();
+		
+		children.reverse();
+
+		ITree<String> arrayTree = new Tree<>("[]", children);
+
+		return arrayTree;
+	}
+
+	private static boolean
+			shouldContinuePopping(Deque<ITree<String>> queuedTrees) {
+		String peekToken = queuedTrees.peek().getHead();
+
+		return !peekToken.equals("[");
+	}
+
 	private static boolean isOperatorNode(String token) {
+		if (StringUtils.containsOnly(token, "\\[")) {
+			return true;
+		} else if (StringUtils.containsOnly(token, "\\]")) {
+			return true;
+		}
+
+		if (token.equals("[]")) {
+			// This is a synthetic operator, constructed by [ and ]
+			return true;
+		}
+
 		try {
 			OperatorDiceNode.fromString(token);
 			return true;
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java
index 05fddf6..6263ea9 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java
@@ -3,6 +3,8 @@ package bjc.dicelang.ast;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.nodes.OperatorDiceNode;
 import bjc.dicelang.ast.nodes.VariableDiceNode;
+import bjc.utils.data.IHolder;
+import bjc.utils.data.Identity;
 import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcdata.ITree;
 import bjc.utils.funcdata.TopDownTransformResult;
@@ -41,6 +43,7 @@ public class DiceASTReferenceSanitizer {
 		switch (((OperatorDiceNode) node)) {
 			case ASSIGN:
 				return TopDownTransformResult.TRANSFORM;
+			case ARRAY:
 			case LET:
 				return TopDownTransformResult.PASSTHROUGH;
 			case ADD:
@@ -60,28 +63,134 @@ public class DiceASTReferenceSanitizer {
 			throw new UnsupportedOperationException(
 					"Assignment must have two arguments.");
 		}
-
+		
 		ITree<IDiceASTNode> nameTree = ast.getChild(0);
 		ITree<IDiceASTNode> valueTree = ast.getChild(1);
 
 		if (!DiceASTUtils.containsSimpleVariable(nameTree)) {
-			throw new UnsupportedOperationException(
-					"Assignment must be between a variable and a expression");
+			if (nameTree.getHead() == OperatorDiceNode.ARRAY) {
+				IHolder<Boolean> allSimpleVariables = new Identity<>(true);
+
+				nameTree.doForChildren((child) -> {
+					if (allSimpleVariables.getValue()) {
+						boolean isSimple =
+								DiceASTUtils.containsSimpleVariable(child);
+
+						allSimpleVariables.replace(isSimple);
+					}
+				});
+
+				if (!allSimpleVariables.getValue()) {
+					throw new UnsupportedOperationException(
+							"Array assignment must be between variables and"
+									+ " a expression/array of expressions");
+				}
+
+				if (valueTree.getHead() == OperatorDiceNode.ARRAY) {
+					if (nameTree.getChildrenCount() != valueTree
+							.getChildrenCount()) {
+						throw new UnsupportedOperationException(
+								"Array assignment between arrays must be"
+										+ " between two arrays of equal length");
+					}
+				}
+			} else {
+				throw new UnsupportedOperationException(
+						"Assignment must be between a variable and a expression");
+			}
+		}
+
+		if (nameTree.getHead() == OperatorDiceNode.ARRAY) {
+			if (valueTree.getHead() == OperatorDiceNode.ARRAY) {
+				IHolder<Integer> childCounter = new Identity<>(0);
+
+				ITree<IDiceASTNode> returnTree =
+						new Tree<>(OperatorDiceNode.ARRAY);
+
+				nameTree.doForChildren((child) -> {
+					String variableName = child.transformHead((node) -> {
+						return ((VariableDiceNode) node).getVariable();
+					});
+
+					ITree<IDiceASTNode> currentValue =
+							valueTree.getChild(childCounter.getValue());
+
+					ITree<IDiceASTNode> sanitizedSubtree =
+							doSingleSanitize(ast, enviroment, child,
+									currentValue, variableName);
+
+					if (sanitizedSubtree == null) {
+						ITree<IDiceASTNode> oldTree = new Tree<>(
+								ast.getHead(), child, currentValue);
+
+						returnTree.addChild(oldTree);
+					} else {
+						returnTree.addChild(sanitizedSubtree);
+					}
+
+					childCounter.transform((count) -> count + 1);
+				});
+
+				return returnTree;
+			}
+
+			ITree<IDiceASTNode> returnTree =
+					new Tree<>(OperatorDiceNode.ARRAY);
+
+			nameTree.doForChildren((child) -> {
+				String variableName = child.transformHead(
+						(node) -> ((VariableDiceNode) node).getVariable());
+
+				ITree<IDiceASTNode> sanitizedChild = doSingleSanitize(ast,
+						enviroment, child, valueTree, variableName);
+				if (sanitizedChild == null) {
+					ITree<IDiceASTNode> oldTree =
+							new Tree<>(ast.getHead(), child, valueTree);
+
+					returnTree.addChild(oldTree);
+				} else {
+					returnTree.addChild(sanitizedChild);
+				}
+			});
+
+			return returnTree;
 		}
 
 		String variableName = nameTree.transformHead(
 				(node) -> ((VariableDiceNode) node).getVariable());
 
+		ITree<IDiceASTNode> sanitizedTree = doSingleSanitize(ast,
+				enviroment, nameTree, valueTree, variableName);
+
+		if (sanitizedTree == null) {
+			return ast;
+		}
+
+		return sanitizedTree;
+	}
+
+	private static ITree<IDiceASTNode> doSingleSanitize(
+			ITree<IDiceASTNode> ast,
+			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment,
+			ITree<IDiceASTNode> nameTree, ITree<IDiceASTNode> valueTree,
+			String variableName) {
 		if (enviroment.containsKey(variableName)) {
+			// @ is a meta-variable standing for the left side of an
+			// assignment
+			enviroment.put("@", enviroment.get(variableName));
+
 			// We should always inline out references to last, because it
 			// will always change
 			ITree<IDiceASTNode> inlinedValue =
 					DiceASTInliner.selectiveInline(valueTree, enviroment,
-							variableName, "last");
+							variableName, "last", "@");
+
+			// Remove temporary meta-variable
+			enviroment.remove("@");
 
 			return new Tree<>(ast.getHead(), nameTree, inlinedValue);
 		}
 
-		return ast;
+		return null;
 	}
 }
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java
index 10df77b..8fd066d 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java
@@ -14,7 +14,7 @@ import bjc.utils.funcdata.ITree;
  *
  */
 public interface IOperatorCollapser extends
-		Function<IFunctionalList<IPair<Integer, ITree<IDiceASTNode>>>,
-							IPair<Integer, ITree<IDiceASTNode>>> {
+		Function<IFunctionalList<IPair<IResult, ITree<IDiceASTNode>>>,
+							IPair<IResult, ITree<IDiceASTNode>>> {
 	// Just an alias
 }
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/IResult.java b/dice-lang/src/main/java/bjc/dicelang/ast/IResult.java
new file mode 100644
index 0000000..9a3f325
--- /dev/null
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/IResult.java
@@ -0,0 +1,16 @@
+package bjc.dicelang.ast;
+
+/**
+ * Represents a result from an expression evaluation
+ * 
+ * @author ben
+ *
+ */
+public interface IResult {
+	/**
+	 * Get the type of this result
+	 * 
+	 * @return The type of this result
+	 */
+	public ResultType getType();
+}
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/IntegerResult.java b/dice-lang/src/main/java/bjc/dicelang/ast/IntegerResult.java
new file mode 100644
index 0000000..c8d9a64
--- /dev/null
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/IntegerResult.java
@@ -0,0 +1,40 @@
+package bjc.dicelang.ast;
+
+/**
+ * Represents a integer-valued result
+ * 
+ * @author ben
+ *
+ */
+public class IntegerResult implements IResult {
+	private int value;
+
+	/**
+	 * Create a new integer valued result
+	 * 
+	 * @param val
+	 *            The value of the result
+	 */
+	public IntegerResult(int val) {
+		value = val;
+	}
+
+	/**
+	 * Get the value of this result
+	 * 
+	 * @return The value of this result
+	 */
+	public int getValue() {
+		return value;
+	}
+
+	@Override
+	public ResultType getType() {
+		return ResultType.INTEGER;
+	}
+
+	@Override
+	public String toString() {
+		return Integer.toString(value);
+	}
+}
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/ResultType.java b/dice-lang/src/main/java/bjc/dicelang/ast/ResultType.java
new file mode 100644
index 0000000..d5e94b9
--- /dev/null
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/ResultType.java
@@ -0,0 +1,18 @@
+package bjc.dicelang.ast;
+
+/**
+ * Represents the result of a computation
+ * 
+ * @author ben
+ *
+ */
+public enum ResultType {
+	/**
+	 * Represents a result that is equivalent to a single integer
+	 */
+	INTEGER,
+	/**
+	 * Represents a result that is an array
+	 */
+	ARRAY;
+}
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java
index c0f7bd3..18df122 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java
@@ -34,6 +34,10 @@ public enum OperatorDiceNode implements IDiceASTNode {
 	 */
 	GROUP(DICE),
 	/**
+	 * Represents constructing an array from a sequence of expressions
+	 */
+	ARRAY(EXPRESSION),
+	/**
 	 * Represents assigning one node to another
 	 */
 	ASSIGN(EXPRESSION),
@@ -79,6 +83,8 @@ public enum OperatorDiceNode implements IDiceASTNode {
 				return COMPOUND;
 			case "=>":
 				return LET;
+			case "[]":
+				return ARRAY;
 			default:
 				throw new IllegalArgumentException(
 						s + " is not a valid operator node");
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
index e476d74..7b746ac 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
@@ -77,6 +77,12 @@ public class ConstantCollapser implements IOptimizationPass {
 				}
 
 				return new Tree<>(operator, children);
+			case ARRAY:
+				if (children.getSize() != 1) {
+					return new Tree<>(operator, children);
+				}
+
+				return children.first();
 			case ASSIGN:
 			case LET:
 			default:
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java
index f41a3ef..3988d2a 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java
@@ -51,6 +51,7 @@ public class OperationCondenser {
 			case DIVIDE:
 			case COMPOUND:
 				return TopDownTransformResult.PUSHDOWN;
+			case ARRAY:
 			case ASSIGN:
 			case GROUP:
 			case LET: