Formatting changes

24 files changed, 161 insertions, 139 deletions

diff --git a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java
index 42368e3..e76a23a 100644
--- a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java
+++ b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java
@@ -1,6 +1,9 @@
 package bjc.dicelang;
 
-import static bjc.dicelang.DiceExpressionType.*;
+import static bjc.dicelang.DiceExpressionType.ADD;
+import static bjc.dicelang.DiceExpressionType.DIVIDE;
+import static bjc.dicelang.DiceExpressionType.MULTIPLY;
+import static bjc.dicelang.DiceExpressionType.SUBTRACT;
 
 /**
  * Build a dice expression piece by piece
diff --git a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java
index d0e013a..0926147 100644
--- a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java
@@ -3,12 +3,12 @@ package bjc.dicelang;
 import java.util.Map;
 import java.util.Stack;
 
-import org.apache.commons.lang3.StringUtils;
-
 import bjc.utils.funcdata.FunctionalStringTokenizer;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.parserutils.ShuntingYard;
 
+import org.apache.commons.lang3.StringUtils;
+
 /**
  * Parse a dice expression from a string
  * 
@@ -30,8 +30,8 @@ public class DiceExpressionParser {
 		/*
 		 * Create a tokenizer over the strings
 		 */
-		FunctionalStringTokenizer tokenizer =
-				new FunctionalStringTokenizer(expression);
+		FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer(
+				expression);
 
 		/*
 		 * Create a shunter to rewrite the expression
@@ -51,8 +51,8 @@ public class DiceExpressionParser {
 		/*
 		 * Shunt the expression to postfix form
 		 */
-		IFunctionalList<String> list =
-				yard.postfix(tokenizer.toList(), s -> s);
+		IFunctionalList<String> list = yard.postfix(tokenizer.toList(),
+				s -> s);
 
 		/*
 		 * Create a stack for building an expression from parts
@@ -90,8 +90,8 @@ public class DiceExpressionParser {
 						/*
 						 * Apply an operation to two dice
 						 */
-						IDiceExpression rightExpression =
-								expressions.pop();
+						IDiceExpression rightExpression = expressions
+								.pop();
 						IDiceExpression leftExpression = expressions.pop();
 
 						switch (expressionPart) {
diff --git a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java
index 013d69d..474e18c 100644
--- a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java
@@ -64,10 +64,8 @@ public interface IDiceExpression {
 			try {
 				return new ScalarDie(Integer.parseInt(literalData));
 			} catch (NumberFormatException nfex) {
-				UnsupportedOperationException usex =
-						new UnsupportedOperationException(
-								"Found malformed leaf token "
-										+ expression);
+				UnsupportedOperationException usex = new UnsupportedOperationException(
+						"Found malformed leaf token " + expression);
 
 				usex.initCause(nfex);
 
diff --git a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java
index 2d47d85..9230680 100644
--- a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java
@@ -65,11 +65,10 @@ public class OperatorDiceExpression implements IDiceExpression {
 				try {
 					return rightExpression.roll() / leftExpression.roll();
 				} catch (ArithmeticException aex) {
-					UnsupportedOperationException usex =
-							new UnsupportedOperationException(
-									"Attempted to divide by zero."
-											+ " Problematic expression is "
-											+ leftExpression);
+					UnsupportedOperationException usex = new UnsupportedOperationException(
+							"Attempted to divide by zero."
+									+ " Problematic expression is "
+									+ leftExpression);
 
 					usex.initCause(aex);
 
diff --git a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java
index 61be936..483545b 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java
@@ -53,7 +53,8 @@ public class ReferenceDiceExpression implements IDiceExpression {
 	public int roll() {
 		if (!enviroment.containsKey(variableName)) {
 			throw new UnsupportedOperationException(
-					"Attempted to reference undefined variable " + variableName);
+					"Attempted to reference undefined variable "
+							+ variableName);
 		}
 
 		return enviroment.get(variableName).roll();
diff --git a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java
index 9c06c31..50315e9 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java
@@ -57,9 +57,8 @@ public class ScalarDiceExpression implements IDiceExpression {
 				try {
 					return expression.roll() / scalar;
 				} catch (ArithmeticException aex) {
-					UnsupportedOperationException usex =
-							new UnsupportedOperationException(
-									"Attempted to divide by zero.");
+					UnsupportedOperationException usex = new UnsupportedOperationException(
+							"Attempted to divide by zero.");
 
 					usex.initCause(aex);
 
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 ad508c8..87cbeb1 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java
@@ -2,14 +2,15 @@ package bjc.dicelang.ast;
 
 import java.util.function.BinaryOperator;
 
-import bjc.dicelang.ast.nodes.IDiceASTNode;
-import bjc.dicelang.ast.nodes.OperatorDiceNode;
 import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.ITree;
 import bjc.utils.funcdata.Tree;
 
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.nodes.OperatorDiceNode;
+
 /**
  * Responsible for collapsing arithmetic operators
  * 
@@ -30,20 +31,20 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 	@Override
 	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));
+		IPair<IResult, ITree<IDiceASTNode>> initState = new Pair<>(
+				new IntegerResult(0), new Tree<>(type));
 
-		BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer =
-				(currentState, accumulatedState) -> {
-					// Force evaluation of accumulated state to prevent
-					// certain bugs from occuring
-					accumulatedState.merge((l, r) -> null);
+		BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer = (
+				currentState, accumulatedState) -> {
+			// Force evaluation of accumulated state to prevent
+			// certain bugs from occuring
+			accumulatedState.merge((l, r) -> null);
 
-					return reduceStates(accumulatedState, currentState);
-				};
+			return reduceStates(accumulatedState, currentState);
+		};
 
-		IPair<IResult, ITree<IDiceASTNode>> reducedState =
-				nodes.reduceAux(initState, reducer, (state) -> state);
+		IPair<IResult, ITree<IDiceASTNode>> reducedState = nodes
+				.reduceAux(initState, reducer, (state) -> state);
 
 		return reducedState;
 	}
@@ -67,10 +68,10 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 	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;
+		boolean currentIsInt = currentValue
+				.getType() == ResultType.INTEGER;
+		boolean accumulatedIsInt = accumulatedValue
+				.getType() == ResultType.INTEGER;
 
 		if (!currentIsInt) {
 			if (!accumulatedIsInt) {
@@ -107,10 +108,10 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 
 	private IFunctionalList<IResult> combineArrayResults(
 			IResult accumulatedValue, IResult currentValue) {
-		IFunctionalList<IResult> currentList =
-				((ArrayResult) currentValue).getValue();
-		IFunctionalList<IResult> accumulatedList =
-				((ArrayResult) accumulatedValue).getValue();
+		IFunctionalList<IResult> currentList = ((ArrayResult) currentValue)
+				.getValue();
+		IFunctionalList<IResult> accumulatedList = ((ArrayResult) accumulatedValue)
+				.getValue();
 
 		if (currentList.getSize() != accumulatedList.getSize()) {
 			throw new UnsupportedOperationException(
@@ -119,8 +120,8 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 
 		IFunctionalList<IResult> resultList = currentList.combineWith(
 				accumulatedList, (currentNode, accumulatedNode) -> {
-					boolean currentNotInt =
-							currentNode.getType() != ResultType.INTEGER;
+					boolean currentNotInt = currentNode
+							.getType() != ResultType.INTEGER;
 					boolean accumulatedNotInt = accumulatedNode
 							.getType() != ResultType.INTEGER;
 
@@ -129,10 +130,10 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 								"Nesting of array operations isn't allowed");
 					}
 
-					int accumulatedInt =
-							((IntegerResult) accumulatedNode).getValue();
-					int currentInt =
-							((IntegerResult) currentNode).getValue();
+					int accumulatedInt = ((IntegerResult) accumulatedNode)
+							.getValue();
+					int currentInt = ((IntegerResult) currentNode)
+							.getValue();
 
 					IResult combinedValue = new IntegerResult(
 							valueOp.apply(accumulatedInt, currentInt));
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 8ed385e..6044602 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
@@ -2,15 +2,6 @@ package bjc.dicelang.ast;
 
 import java.util.function.Supplier;
 
-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;
-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;
@@ -23,6 +14,16 @@ import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcdata.ITree;
 import bjc.utils.funcdata.Tree;
 
+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;
+import bjc.dicelang.ast.nodes.ILiteralDiceNode;
+import bjc.dicelang.ast.nodes.IntegerLiteralNode;
+import bjc.dicelang.ast.nodes.OperatorDiceNode;
+import bjc.dicelang.ast.nodes.VariableDiceNode;
+
 /**
  * Evaluate a dice AST to an integer value
  * 
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java
index 6091cc3..114965e 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java
@@ -1,14 +1,15 @@
 package bjc.dicelang.ast;
 
-import bjc.dicelang.ast.nodes.DiceASTType;
-import bjc.dicelang.ast.nodes.IDiceASTNode;
-import bjc.dicelang.ast.nodes.VariableDiceNode;
 import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcdata.ITree;
 import bjc.utils.funcdata.Tree;
 
+import bjc.dicelang.ast.nodes.DiceASTType;
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.nodes.VariableDiceNode;
+
 /**
  * Inline variables in a dice AST
  * 
@@ -81,8 +82,8 @@ public class DiceASTInliner {
 			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment,
 			String... variables) {
 		if (variables != null && variables.length > 0) {
-			IFunctionalList<String> variableNames =
-					new FunctionalList<>(variables);
+			IFunctionalList<String> variableNames = new FunctionalList<>(
+					variables);
 
 			return ast.flatMapTree((node) -> {
 				return inlineNode(node, enviroment, true, variableNames);
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java
index 7676fac..e96c620 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java
@@ -1,12 +1,13 @@
 package bjc.dicelang.ast;
 
-import bjc.dicelang.ast.nodes.IDiceASTNode;
-import bjc.dicelang.ast.optimization.IOptimizationPass;
 import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcdata.ITree;
 
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.optimization.IOptimizationPass;
+
 /**
  * Contains optimizations appliable to a dice AST
  * 
@@ -44,8 +45,8 @@ public class DiceASTOptimizer {
 	 */
 	public ITree<IDiceASTNode> optimizeTree(ITree<IDiceASTNode> ast,
 			IFunctionalMap<String, ITree<IDiceASTNode>> enviroment) {
-		ITree<IDiceASTNode> optimizedTree =
-				passes.reduceAux(ast, (currentPass, currentTree) -> {
+		ITree<IDiceASTNode> optimizedTree = passes.reduceAux(ast,
+				(currentPass, currentTree) -> {
 					return currentTree.collapse(currentPass::optimizeLeaf,
 							(operator) -> {
 								return (nodes) -> {
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 c746c8b..3a4bccf 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java
@@ -5,14 +5,6 @@ import java.util.InputMismatchException;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
-import bjc.dicelang.IDiceExpression;
-import bjc.dicelang.ast.nodes.DiceLiteralNode;
-import bjc.dicelang.ast.nodes.DiceLiteralType;
-import bjc.dicelang.ast.nodes.IDiceASTNode;
-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;
@@ -22,6 +14,15 @@ import bjc.utils.funcdata.Tree;
 import bjc.utils.funcutils.StringUtils;
 import bjc.utils.parserutils.TreeConstructor;
 
+import bjc.dicelang.IDiceExpression;
+import bjc.dicelang.ast.nodes.DiceLiteralNode;
+import bjc.dicelang.ast.nodes.DiceLiteralType;
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.nodes.ILiteralDiceNode;
+import bjc.dicelang.ast.nodes.IntegerLiteralNode;
+import bjc.dicelang.ast.nodes.OperatorDiceNode;
+import bjc.dicelang.ast.nodes.VariableDiceNode;
+
 /**
  * Parse a string expression into AST form. Doesn't do anything else
  * 
@@ -36,8 +37,8 @@ public class DiceASTParser {
 	 *            The list of tokens to convert
 	 * @return An AST built from the tokens
 	 */
-	public static ITree<IDiceASTNode>
-			createFromString(IFunctionalList<String> tokens) {
+	public static ITree<IDiceASTNode> createFromString(
+			IFunctionalList<String> tokens) {
 		Predicate<String> specialPicker = (operator) -> {
 			if (StringUtils.containsOnly(operator, "\\[")) {
 				return true;
@@ -48,8 +49,7 @@ public class DiceASTParser {
 			return false;
 		};
 
-		IFunctionalMap<String, Function<Deque<ITree<String>>, ITree<String>>> operators =
-				new FunctionalMap<>();
+		IFunctionalMap<String, Function<Deque<ITree<String>>, ITree<String>>> operators = new FunctionalMap<>();
 
 		operators.put("[", (queuedTrees) -> {
 			Tree<String> openTree = new Tree<>("[");
@@ -61,28 +61,28 @@ public class DiceASTParser {
 			return parseCloseArray(queuedTrees);
 		});
 
-		ITree<String> rawTokens =
-				TreeConstructor.constructTree(tokens, (token) -> {
+		ITree<String> rawTokens = TreeConstructor.constructTree(tokens,
+				(token) -> {
 					return isOperatorNode(token);
 				}, specialPicker, operators::get);
 
-		ITree<IDiceASTNode> tokenizedTree =
-				rawTokens.rebuildTree(DiceASTParser::convertLeafNode,
-						DiceASTParser::convertOperatorNode);
+		ITree<IDiceASTNode> tokenizedTree = rawTokens.rebuildTree(
+				DiceASTParser::convertLeafNode,
+				DiceASTParser::convertOperatorNode);
 
 		return tokenizedTree;
 	}
 
-	private static ITree<String>
-			parseCloseArray(Deque<ITree<String>> queuedTrees) {
+	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);
@@ -90,8 +90,8 @@ public class DiceASTParser {
 		return arrayTree;
 	}
 
-	private static boolean
-			shouldContinuePopping(Deque<ITree<String>> queuedTrees) {
+	private static boolean shouldContinuePopping(
+			Deque<ITree<String>> queuedTrees) {
 		String peekToken = queuedTrees.peek().getHead();
 
 		return !peekToken.equals("[");
@@ -119,8 +119,8 @@ public class DiceASTParser {
 	}
 
 	private static IDiceASTNode convertLeafNode(String leafNode) {
-		DiceLiteralType literalType =
-				ILiteralDiceNode.getLiteralType(leafNode);
+		DiceLiteralType literalType = ILiteralDiceNode
+				.getLiteralType(leafNode);
 
 		if (literalType != null) {
 			switch (literalType) {
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java
index 809243a..34414c5 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java
@@ -2,10 +2,11 @@ package bjc.dicelang.ast;
 
 import java.util.function.Consumer;
 
+import bjc.utils.data.IHolder;
+
 import bjc.dicelang.ast.nodes.DiceASTType;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.nodes.VariableDiceNode;
-import bjc.utils.data.IHolder;
 
 /**
  * Check if the specified node references a particular variable
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 9ace97f..3079bca 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java
@@ -1,8 +1,5 @@
 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;
@@ -10,6 +7,10 @@ import bjc.utils.funcdata.ITree;
 import bjc.utils.funcdata.TopDownTransformResult;
 import bjc.utils.funcdata.Tree;
 
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.nodes.OperatorDiceNode;
+import bjc.dicelang.ast.nodes.VariableDiceNode;
+
 /**
  * Sanitize the references in an AST so that a variable that refers to
  * itself in its definition has the occurance of it replaced with its
@@ -47,6 +48,7 @@ public class DiceASTReferenceSanitizer {
 			case LET:
 				return TopDownTransformResult.PASSTHROUGH;
 			case ADD:
+			case CALL:
 			case COMPOUND:
 			case DIVIDE:
 			case GROUP:
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java
index 20a46c7..a70ee00 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java
@@ -1,5 +1,7 @@
 package bjc.dicelang.ast;
 
+import bjc.utils.funcdata.ITree;
+
 import bjc.dicelang.IDiceExpression;
 import bjc.dicelang.ScalarDie;
 import bjc.dicelang.ast.nodes.DiceASTType;
@@ -7,7 +9,6 @@ import bjc.dicelang.ast.nodes.DiceLiteralNode;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.nodes.ILiteralDiceNode;
 import bjc.dicelang.ast.nodes.IntegerLiteralNode;
-import bjc.utils.funcdata.ITree;
 
 /**
  * Functions that are useful when dealing with dice ASTs
@@ -23,8 +24,8 @@ public class DiceASTUtils {
 	 * @return Whether or not a dice AST contains a simple variable
 	 *         reference
 	 */
-	public static boolean
-			containsSimpleVariable(ITree<IDiceASTNode> nameTree) {
+	public static boolean containsSimpleVariable(
+			ITree<IDiceASTNode> nameTree) {
 		return nameTree.transformHead((nameNod) -> {
 			if (nameNod.getType() != DiceASTType.VARIABLE) {
 				return false;
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 8fd066d..a3050a1 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java
@@ -2,11 +2,12 @@ package bjc.dicelang.ast;
 
 import java.util.function.Function;
 
-import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.utils.data.IPair;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.ITree;
 
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+
 /**
  * Alias for operator collapsers. Because 68-char types are too long
  * 
@@ -14,7 +15,6 @@ import bjc.utils.funcdata.ITree;
  *
  */
 public interface IOperatorCollapser extends
-		Function<IFunctionalList<IPair<IResult, ITree<IDiceASTNode>>>,
-							IPair<IResult, 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/nodes/DiceOperatorType.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceOperatorType.java
index 76aa2e3..7cc1e42 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceOperatorType.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceOperatorType.java
@@ -15,6 +15,10 @@ public enum DiceOperatorType {
 	 */
 	MATH,
 	/**
+	 * Represents operators that do things with arrays
+	 */
+	ARRAY,
+	/**
 	 * Represents operators that do things with dice
 	 */
 	DICE,
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 18df122..411548a 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
@@ -1,6 +1,8 @@
 package bjc.dicelang.ast.nodes;
 
-import static bjc.dicelang.ast.nodes.DiceOperatorType.*;
+import static bjc.dicelang.ast.nodes.DiceOperatorType.DICE;
+import static bjc.dicelang.ast.nodes.DiceOperatorType.EXPRESSION;
+import static bjc.dicelang.ast.nodes.DiceOperatorType.MATH;
 
 /**
  * A node that represents an operator
@@ -36,12 +38,16 @@ public enum OperatorDiceNode implements IDiceASTNode {
 	/**
 	 * Represents constructing an array from a sequence of expressions
 	 */
-	ARRAY(EXPRESSION),
+	ARRAY(DiceOperatorType.ARRAY),
 	/**
 	 * Represents assigning one node to another
 	 */
 	ASSIGN(EXPRESSION),
 	/**
+	 * Represents calling a function
+	 */
+	CALL(EXPRESSION),
+	/**
 	 * Represents evaluating one expression in the context of another
 	 */
 	LET(EXPRESSION);
@@ -85,6 +91,8 @@ public enum OperatorDiceNode implements IDiceASTNode {
 				return LET;
 			case "[]":
 				return ARRAY;
+			case "call":
+				return CALL;
 			default:
 				throw new IllegalArgumentException(
 						s + " is not a valid operator node");
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java
index cfa2511..f0f7366 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java
@@ -1,5 +1,6 @@
 /**
  * Classes for nodes in the dice-lang AST
+ * 
  * @author ben
  *
  */
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java
index 5318119..2b2a9ad 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java
@@ -2,15 +2,16 @@ package bjc.dicelang.ast.optimization;
 
 import java.util.function.BinaryOperator;
 
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.ITree;
+import bjc.utils.funcdata.Tree;
+
 import bjc.dicelang.ast.DiceASTUtils;
 import bjc.dicelang.ast.nodes.DiceASTType;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.nodes.ILiteralDiceNode;
 import bjc.dicelang.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.ast.nodes.OperatorDiceNode;
-import bjc.utils.funcdata.IFunctionalList;
-import bjc.utils.funcdata.ITree;
-import bjc.utils.funcdata.Tree;
 
 class ArithmeticCollapser {
 	private BinaryOperator<Integer>	reducer;
@@ -22,8 +23,8 @@ class ArithmeticCollapser {
 		this.type = typ;
 	}
 
-	public ITree<IDiceASTNode>
-			collapse(IFunctionalList<ITree<IDiceASTNode>> children) {
+	public ITree<IDiceASTNode> collapse(
+			IFunctionalList<ITree<IDiceASTNode>> children) {
 		boolean allConstant = children.allMatch((subtree) -> {
 			return subtree.transformHead((node) -> {
 				if (node.getType() == DiceASTType.LITERAL) {
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 7b746ac..63c9037 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
@@ -1,13 +1,14 @@
 package bjc.dicelang.ast.optimization;
 
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.ITree;
+import bjc.utils.funcdata.Tree;
+
 import bjc.dicelang.ComplexDice;
 import bjc.dicelang.ast.DiceASTUtils;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.dicelang.ast.nodes.IntegerLiteralNode;
 import bjc.dicelang.ast.nodes.OperatorDiceNode;
-import bjc.utils.funcdata.IFunctionalList;
-import bjc.utils.funcdata.ITree;
-import bjc.utils.funcdata.Tree;
 
 /**
  * Collapses operations with constants to constants
@@ -16,27 +17,22 @@ import bjc.utils.funcdata.Tree;
  *
  */
 public class ConstantCollapser implements IOptimizationPass {
-	private static final ArithmeticCollapser	additionCollapser	=
-			new ArithmeticCollapser((left, right) -> left + right,
-					OperatorDiceNode.ADD);
+	private static final ArithmeticCollapser	additionCollapser	= new ArithmeticCollapser(
+			(left, right) -> left + right, OperatorDiceNode.ADD);
 
-	private static final ArithmeticCollapser	divideCollapser		=
-			new ArithmeticCollapser((left, right) -> left / right,
-					OperatorDiceNode.DIVIDE);
+	private static final ArithmeticCollapser	divideCollapser		= new ArithmeticCollapser(
+			(left, right) -> left / right, OperatorDiceNode.DIVIDE);
 
-	private static final ArithmeticCollapser	multiplyCollapser	=
-			new ArithmeticCollapser((left, right) -> left * right,
-					OperatorDiceNode.MULTIPLY);
+	private static final ArithmeticCollapser	multiplyCollapser	= new ArithmeticCollapser(
+			(left, right) -> left * right, OperatorDiceNode.MULTIPLY);
 
-	private static final ArithmeticCollapser	subtractCollapser	=
-			new ArithmeticCollapser((left, right) -> left - right,
-					OperatorDiceNode.SUBTRACT);
+	private static final ArithmeticCollapser	subtractCollapser	= new ArithmeticCollapser(
+			(left, right) -> left - right, OperatorDiceNode.SUBTRACT);
 
-	private static final ArithmeticCollapser	compoundCollapser	=
-			new ArithmeticCollapser((left,
-					right) -> Integer.parseInt(Integer.toString(left)
-							+ Integer.toString(left)),
-					OperatorDiceNode.SUBTRACT);
+	private static final ArithmeticCollapser	compoundCollapser	= new ArithmeticCollapser(
+			(left, right) -> Integer.parseInt(
+					Integer.toString(left) + Integer.toString(left)),
+			OperatorDiceNode.SUBTRACT);
 
 	@Override
 	public ITree<IDiceASTNode> optimizeLeaf(IDiceASTNode leafNode) {
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java
index b631fb5..7dbea18 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java
@@ -1,9 +1,10 @@
 package bjc.dicelang.ast.optimization;
 
-import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.ITree;
 
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+
 /**
  * Represents a pass of optimizations over a dice AST
  * 
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 3988d2a..bdf7b04 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
@@ -1,14 +1,15 @@
 package bjc.dicelang.ast.optimization;
 
-import bjc.dicelang.ast.nodes.DiceASTType;
-import bjc.dicelang.ast.nodes.IDiceASTNode;
-import bjc.dicelang.ast.nodes.OperatorDiceNode;
 import bjc.utils.data.IHolder;
 import bjc.utils.data.Identity;
 import bjc.utils.funcdata.ITree;
 import bjc.utils.funcdata.TopDownTransformResult;
 import bjc.utils.funcdata.Tree;
 
+import bjc.dicelang.ast.nodes.DiceASTType;
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.nodes.OperatorDiceNode;
+
 /**
  * Condenses chained operations into a single level
  * 
@@ -42,8 +43,8 @@ public class OperationCondenser {
 		}
 	}
 
-	private static TopDownTransformResult
-			pickOperator(OperatorDiceNode node) {
+	private static TopDownTransformResult pickOperator(
+			OperatorDiceNode node) {
 		switch (node) {
 			case ADD:
 			case MULTIPLY:
@@ -62,10 +63,10 @@ public class OperationCondenser {
 		}
 	}
 
-	private static ITree<IDiceASTNode>
-			doCondense(ITree<IDiceASTNode> ast) {
-		OperatorDiceNode operation =
-				ast.transformHead((node) -> (OperatorDiceNode) node);
+	private static ITree<IDiceASTNode> doCondense(
+			ITree<IDiceASTNode> ast) {
+		OperatorDiceNode operation = ast
+				.transformHead((node) -> (OperatorDiceNode) node);
 
 		IHolder<Boolean> canCondense = new Identity<>(true);
 
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java
index a3ec93c..6f75bf9 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java
@@ -1,5 +1,6 @@
 /**
  * Contains optimizations on dice ASTs
+ * 
  * @author ben
  *
  */
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java b/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java
index 105af50..f6352aa 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java
@@ -1,5 +1,6 @@
 /**
  * New implementation of AST for dice-lang
+ * 
  * @author ben
  *
  */