Minor cleanups

10 files changed, 220 insertions, 175 deletions

diff --git a/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java b/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java
index 9b8f0bd..7ed4e3b 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java
@@ -11,15 +11,15 @@ public class ComplexDice implements IDiceExpression {
 	/**
 	 * Create a dice from a string expression
 	 * 
-	 * @param dice
+	 * @param expression
 	 *            The string to parse the dice from
 	 * @return A dice group parsed from the string
 	 */
-	public static IDiceExpression fromString(String dice) {
+	public static IDiceExpression fromString(String expression) {
 		/*
 		 * Split it on the dice type marker
 		 */
-		String[] strangs = dice.split("d");
+		String[] strangs = expression.split("d");
 
 		try {
 			/*
@@ -129,6 +129,11 @@ public class ComplexDice implements IDiceExpression {
 
 	@Override
 	public int optimize() {
+		if (!canOptimize()) {
+			throw new UnsupportedOperationException(
+					"This complex dice cannot be optimized");
+		}
+
 		return nDice.optimize();
 	}
 }
\ No newline at end of file
diff --git a/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java b/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java
index 6f7319a..8d2aadd 100644
--- a/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java
+++ b/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java
@@ -13,48 +13,65 @@ public class CompoundDice implements IDiceExpression {
 	/**
 	 * The left die of the expression
 	 */
-	private IDiceExpression	l;
+	private IDiceExpression	leftDice;
 
 	/**
 	 * The right die of the expression
 	 */
-	private IDiceExpression	r;
+	private IDiceExpression	rightDice;
 
 	/**
 	 * Create a new compound dice using the specified dice
 	 * 
-	 * @param l
+	 * @param left
 	 *            The die to use on the left
-	 * @param r
+	 * @param right
 	 *            The die to use on the right
 	 */
-	public CompoundDice(IDiceExpression l, IDiceExpression r) {
-		this.l = l;
-		this.r = r;
+	public CompoundDice(IDiceExpression left, IDiceExpression right) {
+		this.leftDice = left;
+		this.rightDice = right;
 	}
 
 	/**
 	 * Create a new compound dice from two dice strings
 	 * 
-	 * @param l
-	 *            The left side dice
-	 * @param r
-	 *            The right side dice
+	 * @param leftExp
+	 *            The left side dice as a string
+	 * @param rightExp
+	 *            The right side dice as a string
 	 */
-	public CompoundDice(String l, String r) {
-		this(ComplexDice.fromString(l), ComplexDice.fromString(r));
+	public CompoundDice(String leftExp, String rightExp) {
+		this(ComplexDice.fromString(leftExp),
+				ComplexDice.fromString(rightExp));
 	}
 
 	/**
 	 * Create a new compound dice from an array of dice strings
 	 * 
 	 * @param exps
-	 *            An array of dice strings
+	 *            An array of two dice strings
 	 */
 	public CompoundDice(String[] exps) {
 		this(exps[0], exps[1]);
 	}
 
+	@Override
+	public boolean canOptimize() {
+		return leftDice.canOptimize() && rightDice.canOptimize();
+	}
+
+	@Override
+	public int optimize() {
+		if (!canOptimize()) {
+			throw new UnsupportedOperationException(
+					"Cannot optimize this compound dice");
+		}
+
+		return Integer
+				.parseInt(leftDice.optimize() + "" + rightDice.optimize());
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * 
@@ -65,7 +82,7 @@ public class CompoundDice implements IDiceExpression {
 		/*
 		 * Make the combination of the two dice
 		 */
-		return Integer.parseInt(l.roll() + "" + r.roll());
+		return Integer.parseInt(leftDice.roll() + "" + rightDice.roll());
 	}
 
 	/*
@@ -75,16 +92,7 @@ public class CompoundDice implements IDiceExpression {
 	 */
 	@Override
 	public String toString() {
-		return "compound[l=" + l.toString() + ", r=" + r.toString() + "]";
-	}
-
-	@Override
-	public int optimize() {
-		return Integer.parseInt(l.optimize() + "" + r.optimize());
-	}
-
-	@Override
-	public boolean canOptimize() {
-		return l.canOptimize() && r.canOptimize();
+		return "compound[l=" + leftDice.toString() + ", r="
+				+ rightDice.toString() + "]";
 	}
 }
\ No newline at end of file
diff --git a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java
index 8a8ded3..76ccdd4 100644
--- a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java
+++ b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java
@@ -19,18 +19,19 @@ public class DiceExpressionParser {
 	/**
 	 * Parse a dice expression from a string
 	 * 
-	 * @param exp
+	 * @param expression
 	 *            The string to parse an expression from
-	 * @param env
+	 * @param enviroment
 	 *            The enviroment to use when parsing expressions
 	 * @return The parsed dice expression
 	 */
-	public static IDiceExpression parse(String exp,
-			Map<String, IDiceExpression> env) {
+	public static IDiceExpression parse(String expression,
+			Map<String, IDiceExpression> enviroment) {
 		/*
 		 * Create a tokenizer over the strings
 		 */
-		FunctionalStringTokenizer fst = new FunctionalStringTokenizer(exp);
+		FunctionalStringTokenizer tokenizer =
+				new FunctionalStringTokenizer(expression);
 
 		/*
 		 * Create a shunter to rewrite the expression
@@ -50,72 +51,90 @@ public class DiceExpressionParser {
 		/*
 		 * Shunt the expression to postfix form
 		 */
-		IFunctionalList<String> ls = yard.postfix(fst.toList(s -> s),
-				s -> s);
+		IFunctionalList<String> list =
+				yard.postfix(tokenizer.toList(), s -> s);
 
 		/*
 		 * Create a stack for building an expression from parts
 		 */
-		Stack<IDiceExpression> dexps = new Stack<>();
+		Stack<IDiceExpression> expressions = new Stack<>();
 
 		/*
 		 * Create the expression from parts
 		 */
-		ls.forEach((tok) -> {
+		list.forEach((expressionPart) -> {
 			/*
 			 * Handle compound dice
 			 */
-			if (StringUtils.countMatches(tok, 'c') == 1
-					&& !tok.equalsIgnoreCase("c")) {
-				String[] strangs = tok.split("c");
+			if (StringUtils.countMatches(expressionPart, 'c') == 1
+					&& !expressionPart.equalsIgnoreCase("c")) {
+				String[] strangs = expressionPart.split("c");
 
-				dexps.push(new CompoundDice(strangs));
-			} else if (StringUtils.countMatches(tok, 'd') == 1
-					&& !tok.equalsIgnoreCase("d")) {
+				expressions.push(new CompoundDice(strangs));
+			} else if (StringUtils.countMatches(expressionPart, 'd') == 1
+					&& !expressionPart.equalsIgnoreCase("d")) {
 				/*
 				 * Handle dice groups
 				 */
-				dexps.push(ComplexDice.fromString(tok));
+				expressions.push(ComplexDice.fromString(expressionPart));
 			} else {
 				try {
 					/*
 					 * Handle scalar numbers
 					 */
-					dexps.push(new ScalarDie(Integer.parseInt(tok)));
+					expressions.push(new ScalarDie(
+							Integer.parseInt(expressionPart)));
 				} catch (@SuppressWarnings("unused") NumberFormatException nfex) {
 					// We don't care about details, just that it failed
-					if (dexps.size() >= 2) {
+					if (expressions.size() >= 2) {
 						/*
 						 * Apply an operation to two dice
 						 */
-						IDiceExpression r = dexps.pop();
-						IDiceExpression l = dexps.pop();
-						switch (tok) {
+						IDiceExpression rightExpression =
+								expressions.pop();
+						IDiceExpression leftExpression = expressions.pop();
+
+						switch (expressionPart) {
 							case ":=":
-								dexps.push(new BindingDiceExpression(l, r,
-										env));
+								expressions.push(new BindingDiceExpression(
+										leftExpression, rightExpression,
+										enviroment));
 								break;
 							case "+":
-								dexps.push(new OperatorDiceExpression(r, l,
-										DiceExpressionType.ADD));
+								expressions
+										.push(new OperatorDiceExpression(
+												rightExpression,
+												leftExpression,
+												DiceExpressionType.ADD));
 								break;
 							case "-":
-								dexps.push(new OperatorDiceExpression(r, l,
-										DiceExpressionType.SUBTRACT));
+								expressions
+										.push(new OperatorDiceExpression(
+												rightExpression,
+												leftExpression,
+												DiceExpressionType.SUBTRACT));
 								break;
 							case "*":
-								dexps.push(new OperatorDiceExpression(r, l,
-										DiceExpressionType.MULTIPLY));
+								expressions
+										.push(new OperatorDiceExpression(
+												rightExpression,
+												leftExpression,
+												DiceExpressionType.MULTIPLY));
 								break;
 							case "/":
-								dexps.push(new OperatorDiceExpression(r, l,
-										DiceExpressionType.DIVIDE));
+								expressions
+										.push(new OperatorDiceExpression(
+												rightExpression,
+												leftExpression,
+												DiceExpressionType.DIVIDE));
 								break;
 							case "c":
-								dexps.push(new CompoundDice(l, r));
+								expressions.push(new CompoundDice(
+										leftExpression, rightExpression));
 								break;
 							case "d":
-								dexps.push(new ComplexDice(l, r));
+								expressions.push(new ComplexDice(
+										leftExpression, rightExpression));
 								break;
 							default:
 								/*
@@ -123,23 +142,26 @@ public class DiceExpressionParser {
 								 * 
 								 * Make sure to restore popped variables
 								 */
-								dexps.push(l);
-								dexps.push(r);
+								expressions.push(leftExpression);
+								expressions.push(rightExpression);
 
-								dexps.push(new ReferenceDiceExpression(tok,
-										env));
+								expressions
+										.push(new ReferenceDiceExpression(
+												expressionPart,
+												enviroment));
 						}
 					} else {
 						/*
 						 * Parse it as a variable reference
 						 */
-						dexps.push(new ReferenceDiceExpression(tok, env));
+						expressions.push(new ReferenceDiceExpression(
+								expressionPart, enviroment));
 					}
 				}
 			}
 		});
 
-		if (dexps.size() != 1) {
+		if (expressions.size() != 1) {
 			System.err.println(
 					"WARNING: Leftovers found on dice expression stack. Remember, := is assignment.");
 		}
@@ -147,6 +169,6 @@ public class DiceExpressionParser {
 		/*
 		 * Return the built expression
 		 */
-		return dexps.pop();
+		return expressions.pop();
 	}
 }
diff --git a/dice-lang/src/main/java/bjc/dicelang/Die.java b/dice-lang/src/main/java/bjc/dicelang/Die.java
index 5ad5d79..192daaa 100644
--- a/dice-lang/src/main/java/bjc/dicelang/Die.java
+++ b/dice-lang/src/main/java/bjc/dicelang/Die.java
@@ -34,6 +34,21 @@ public class Die implements IDiceExpression {
 		this.nSides = nSides;
 	}
 
+	@Override
+	public boolean canOptimize() {
+		return nSides == 1;
+	}
+
+	@Override
+	public int optimize() {
+		if (nSides != 1) {
+			throw new UnsupportedOperationException(
+					"Can't optimize " + nSides + "-sided dice");
+		}
+
+		return 1;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * 
@@ -53,14 +68,4 @@ public class Die implements IDiceExpression {
 	public String toString() {
 		return "d" + nSides;
 	}
-
-	@Override
-	public int optimize() {
-		return 1;
-	}
-
-	@Override
-	public boolean canOptimize() {
-		return nSides == 1;
-	}
 }
diff --git a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java
index 16e1761..013d69d 100644
--- a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java
@@ -42,19 +42,20 @@ public interface IDiceExpression {
 
 	/**
 	 * Parse this node into an expression
-	 * @param exp The string to convert to an expression
 	 * 
-	 * @return The node in expression form
+	 * @param expression
+	 *            The string to convert to an expression
+	 * 
+	 * @return The string in expression form
 	 */
-	static IDiceExpression toExpression(String exp) {
-		String literalData = exp;
-	
+	static IDiceExpression toExpression(String expression) {
+		String literalData = expression;
+
 		if (StringUtils.containsInfixOperator(literalData, "c")) {
 			String[] strangs = literalData.split("c");
-	
+
 			return new CompoundDice(strangs);
-		} else if (StringUtils.containsInfixOperator(literalData,
-				"d")) {
+		} else if (StringUtils.containsInfixOperator(literalData, "d")) {
 			/*
 			 * Handle dice groups
 			 */
@@ -63,11 +64,13 @@ public interface IDiceExpression {
 			try {
 				return new ScalarDie(Integer.parseInt(literalData));
 			} catch (NumberFormatException nfex) {
-				UnsupportedOperationException usex = new UnsupportedOperationException(
-						"Found malformed leaf token " + exp);
-	
+				UnsupportedOperationException usex =
+						new UnsupportedOperationException(
+								"Found malformed leaf token "
+										+ expression);
+
 				usex.initCause(nfex);
-	
+
 				throw usex;
 			}
 		}
diff --git a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java
index 4779bb9..2d47d85 100644
--- a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java
@@ -10,17 +10,17 @@ public class OperatorDiceExpression implements IDiceExpression {
 	/**
 	 * The operator to use for combining the dice
 	 */
-	private DiceExpressionType	det;
+	private DiceExpressionType	expressionType;
 
 	/**
 	 * The dice on the left side of the expression
 	 */
-	private IDiceExpression		left;
+	private IDiceExpression		leftExpression;
 
 	/**
 	 * The dice on the right side of the expression
 	 */
-	private IDiceExpression		right;
+	private IDiceExpression		rightExpression;
 
 	/**
 	 * Create a new compound expression using the specified parameters
@@ -29,14 +29,14 @@ public class OperatorDiceExpression implements IDiceExpression {
 	 *            The die on the right side of the expression
 	 * @param left
 	 *            The die on the left side of the expression
-	 * @param det
+	 * @param type
 	 *            The operator to use for combining the dices
 	 */
 	public OperatorDiceExpression(IDiceExpression right,
-			IDiceExpression left, DiceExpressionType det) {
-		this.right = right;
-		this.left = left;
-		this.det = det;
+			IDiceExpression left, DiceExpressionType type) {
+		this.rightExpression = right;
+		this.leftExpression = left;
+		this.expressionType = type;
 	}
 
 	/*
@@ -49,26 +49,27 @@ public class OperatorDiceExpression implements IDiceExpression {
 		/*
 		 * Handle each operator
 		 */
-		switch (det) {
+		switch (expressionType) {
 			case ADD:
-				return right.roll() + left.roll();
+				return rightExpression.roll() + leftExpression.roll();
 			case SUBTRACT:
-				return right.roll() - left.roll();
+				return rightExpression.roll() - leftExpression.roll();
 			case MULTIPLY:
-				return right.roll() * left.roll();
+				return rightExpression.roll() * leftExpression.roll();
 			case DIVIDE:
 				/*
 				 * Round to keep results as integers. We don't really have
-				 * any need for floating-point dice
+				 * any need for floating-point dice, and continuous
+				 * probability is a pain
 				 */
 				try {
-					return right.roll() / left.roll();
+					return rightExpression.roll() / leftExpression.roll();
 				} catch (ArithmeticException aex) {
 					UnsupportedOperationException usex =
 							new UnsupportedOperationException(
 									"Attempted to divide by zero."
 											+ " Problematic expression is "
-											+ left);
+											+ leftExpression);
 
 					usex.initCause(aex);
 
@@ -76,8 +77,8 @@ public class OperatorDiceExpression implements IDiceExpression {
 				}
 			default:
 				throw new IllegalArgumentException(
-						"Got passed  a invalid ScalarExpressionType " + det
-								+ ". WAT");
+						"Got passed  a invalid ScalarExpressionType "
+								+ expressionType + ". WAT");
 
 		}
 	}
@@ -89,7 +90,8 @@ public class OperatorDiceExpression implements IDiceExpression {
 	 */
 	@Override
 	public String toString() {
-		return "dice-exp[type=" + det + ", l=" + left.toString() + ", r="
-				+ right.toString() + "]";
+		return "dice-exp[type=" + expressionType + ", l="
+				+ leftExpression.toString() + ", r="
+				+ rightExpression.toString() + "]";
 	}
 }
\ No newline at end of file
diff --git a/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java b/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java
index 9f609b4..3ac9420 100644
--- a/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java
+++ b/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java
@@ -8,6 +8,15 @@ package bjc.dicelang;
  */
 public class PolyhedralDice {
 	/**
+	 * Produce a single d10
+	 * 
+	 * @return A single d10
+	 */
+	public static IDiceExpression d10() {
+		return d10(1);
+	}
+
+	/**
 	 * Produce the specified number of 10-sided dice
 	 * 
 	 * @param nDice
@@ -19,12 +28,12 @@ public class PolyhedralDice {
 	}
 
 	/**
-	 * Produce a single d10
+	 * Produce a single d100
 	 * 
-	 * @return A single d10
+	 * @return A single d100
 	 */
-	public static IDiceExpression d10() {
-		return d10(1);
+	public static IDiceExpression d100() {
+		return d100(1);
 	}
 
 	/**
@@ -39,12 +48,12 @@ public class PolyhedralDice {
 	}
 
 	/**
-	 * Produce a single d100
+	 * Produce a single d12
 	 * 
-	 * @return A single d100
+	 * @return A single d12
 	 */
-	public static IDiceExpression d100() {
-		return d100(1);
+	public static IDiceExpression d12() {
+		return d12(1);
 	}
 
 	/**
@@ -59,12 +68,12 @@ public class PolyhedralDice {
 	}
 
 	/**
-	 * Produce a single d12
+	 * Produce a single d20
 	 * 
-	 * @return A single d12
+	 * @return A single d20
 	 */
-	public static IDiceExpression d12() {
-		return d12(1);
+	public static IDiceExpression d20() {
+		return d20(1);
 	}
 
 	/**
@@ -79,12 +88,12 @@ public class PolyhedralDice {
 	}
 
 	/**
-	 * Produce a single d20
+	 * Produce a single d4
 	 * 
-	 * @return A single d20
+	 * @return A single d4
 	 */
-	public static IDiceExpression d20() {
-		return d20(1);
+	public static IDiceExpression d4() {
+		return d4(1);
 	}
 
 	/**
@@ -99,12 +108,12 @@ public class PolyhedralDice {
 	}
 
 	/**
-	 * Produce a single d4
+	 * Produce a single d6
 	 * 
-	 * @return A single d4
+	 * @return A single d6
 	 */
-	public static IDiceExpression d4() {
-		return d4(1);
+	public static IDiceExpression d6() {
+		return d6(1);
 	}
 
 	/**
@@ -119,12 +128,12 @@ public class PolyhedralDice {
 	}
 
 	/**
-	 * Produce a single d6
+	 * Produce a single d8
 	 * 
-	 * @return A single d6
+	 * @return A single d8
 	 */
-	public static IDiceExpression d6() {
-		return d6(1);
+	public static IDiceExpression d8() {
+		return d8(1);
 	}
 
 	/**
@@ -137,13 +146,4 @@ public class PolyhedralDice {
 	public static IDiceExpression d8(int nDice) {
 		return new ComplexDice(nDice, 8);
 	}
-
-	/**
-	 * Produce a single d8
-	 * 
-	 * @return A single d8
-	 */
-	public static IDiceExpression d8() {
-		return d8(1);
-	}
 }
diff --git a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java
index b7be527..61be936 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java
@@ -13,12 +13,12 @@ public class ReferenceDiceExpression implements IDiceExpression {
 	/**
 	 * The enviroment to do variable dereferencing against
 	 */
-	private Map<String, IDiceExpression>	env;
+	private Map<String, IDiceExpression>	enviroment;
 
 	/**
 	 * The name of the bound variable
 	 */
-	private String							name;
+	private String							variableName;
 
 	/**
 	 * Create a new reference dice expression referring to the given name
@@ -31,8 +31,8 @@ public class ReferenceDiceExpression implements IDiceExpression {
 	 */
 	public ReferenceDiceExpression(String name,
 			Map<String, IDiceExpression> env) {
-		this.name = name;
-		this.env = env;
+		this.variableName = name;
+		this.enviroment = env;
 	}
 
 	/**
@@ -41,7 +41,7 @@ public class ReferenceDiceExpression implements IDiceExpression {
 	 * @return the name of the referenced variable
 	 */
 	public String getName() {
-		return name;
+		return variableName;
 	}
 
 	/*
@@ -51,12 +51,12 @@ public class ReferenceDiceExpression implements IDiceExpression {
 	 */
 	@Override
 	public int roll() {
-		if (!env.containsKey(name)) {
+		if (!enviroment.containsKey(variableName)) {
 			throw new UnsupportedOperationException(
-					"Attempted to reference undefined variable " + name);
+					"Attempted to reference undefined variable " + variableName);
 		}
 
-		return env.get(name).roll();
+		return enviroment.get(variableName).roll();
 	}
 
 	/*
@@ -66,10 +66,10 @@ public class ReferenceDiceExpression implements IDiceExpression {
 	 */
 	@Override
 	public String toString() {
-		if (env.containsKey(name)) {
-			return env.get(name).toString();
+		if (enviroment.containsKey(variableName)) {
+			return enviroment.get(variableName).toString();
 		}
 
-		return name;
+		return variableName;
 	}
 }
\ No newline at end of file
diff --git a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java
index d28633f..9c06c31 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java
@@ -10,12 +10,12 @@ public class ScalarDiceExpression implements IDiceExpression {
 	/**
 	 * The operation to combine with
 	 */
-	private DiceExpressionType	det;
+	private DiceExpressionType	expressionType;
 
 	/**
 	 * The expression to be combined
 	 */
-	private IDiceExpression		exp;
+	private IDiceExpression		expression;
 
 	/**
 	 * The scalar to be combined
@@ -25,18 +25,18 @@ public class ScalarDiceExpression implements IDiceExpression {
 	/**
 	 * Create a dice expression with a scalar
 	 * 
-	 * @param dex
+	 * @param expr
 	 *            The dice to use
 	 * @param scalr
 	 *            The scalar to use
-	 * @param dt
+	 * @param type
 	 *            The operation to combine with
 	 */
-	public ScalarDiceExpression(IDiceExpression dex, int scalr,
-			DiceExpressionType dt) {
-		exp = dex;
+	public ScalarDiceExpression(IDiceExpression expr, int scalr,
+			DiceExpressionType type) {
+		expression = expr;
 		scalar = scalr;
-		det = dt;
+		expressionType = type;
 	}
 
 	/*
@@ -46,16 +46,16 @@ public class ScalarDiceExpression implements IDiceExpression {
 	 */
 	@Override
 	public int roll() {
-		switch (det) {
+		switch (expressionType) {
 			case ADD:
-				return exp.roll() + scalar;
+				return expression.roll() + scalar;
 			case SUBTRACT:
-				return exp.roll() - scalar;
+				return expression.roll() - scalar;
 			case MULTIPLY:
-				return exp.roll() * scalar;
+				return expression.roll() * scalar;
 			case DIVIDE:
 				try {
-					return exp.roll() / scalar;
+					return expression.roll() / scalar;
 				} catch (ArithmeticException aex) {
 					UnsupportedOperationException usex =
 							new UnsupportedOperationException(
@@ -68,7 +68,7 @@ public class ScalarDiceExpression implements IDiceExpression {
 			default:
 				throw new IllegalStateException(
 						"Got passed  a invalid ScalarExpressionType "
-								+ det);
+								+ expressionType);
 		}
 	}
 
@@ -79,7 +79,7 @@ public class ScalarDiceExpression implements IDiceExpression {
 	 */
 	@Override
 	public String toString() {
-		return "scalar-exp[type=" + det + ", l=" + scalar + ", r="
-				+ exp.toString() + "]";
+		return "scalar-exp[type=" + expressionType + ", l=" + scalar
+				+ ", r=" + expression.toString() + "]";
 	}
 }
\ No newline at end of file
diff --git a/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java b/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java
index fa25818..1d64dc2 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java
@@ -10,7 +10,7 @@ public class ScalarDie implements IDiceExpression {
 	/**
 	 * The represented number
 	 */
-	private int num;
+	private int number;
 
 	/**
 	 * Create a dice with the specified number
@@ -19,7 +19,7 @@ public class ScalarDie implements IDiceExpression {
 	 *            The number used for the dice
 	 */
 	public ScalarDie(int num) {
-		this.num = num;
+		this.number = num;
 	}
 
 	/*
@@ -29,7 +29,7 @@ public class ScalarDie implements IDiceExpression {
 	 */
 	@Override
 	public int roll() {
-		return num;
+		return number;
 	}
 
 	/*
@@ -39,12 +39,12 @@ public class ScalarDie implements IDiceExpression {
 	 */
 	@Override
 	public String toString() {
-		return Integer.toString(num);
+		return Integer.toString(number);
 	}
 
 	@Override
 	public int optimize() {
-		return num;
+		return number;
 	}
 
 	@Override