Adapt to esodata changes

33 files changed, 115 insertions, 115 deletions

diff --git a/JPratt/src/examples/java/bjc/pratt/examples/lang/AssignCommand.java b/JPratt/src/examples/java/bjc/pratt/examples/lang/AssignCommand.java
index f816307..78fec0d 100644
--- a/JPratt/src/examples/java/bjc/pratt/examples/lang/AssignCommand.java
+++ b/JPratt/src/examples/java/bjc/pratt/examples/lang/AssignCommand.java
@@ -4,8 +4,8 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.commands.impls.NonBinaryCommand;
 import bjc.pratt.tokens.StringToken;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 class AssignCommand extends NonBinaryCommand<String, String, TestContext> {
@@ -14,7 +14,7 @@ class AssignCommand extends NonBinaryCommand<String, String, TestContext> {
 	}
 
 	@Override
-	public ITree<Token<String, String>> denote(final ITree<Token<String, String>> operand,
+	public Tree<Token<String, String>> denote(final Tree<Token<String, String>> operand,
 			final Token<String, String> operator, final ParserContext<String, String, TestContext> ctx)
 			throws ParserException {
 		final Token<String, String> name = operand.getHead();
@@ -27,10 +27,10 @@ class AssignCommand extends NonBinaryCommand<String, String, TestContext> {
 			throw new ParserException("Variable name must be simple");
 		}
 
-		final ITree<Token<String, String>> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
+		final Tree<Token<String, String>> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
 
 		ctx.state.scopes.top().putKey(name.getValue(), body);
 
-		return new Tree<>(new StringToken("assign", "assign"), operand, body);
+		return new SimpleTree<>(new StringToken("assign", "assign"), operand, body);
 	}
 }
diff --git a/JPratt/src/examples/java/bjc/pratt/examples/lang/BlockEnter.java b/JPratt/src/examples/java/bjc/pratt/examples/lang/BlockEnter.java
index 143678c..e175ff5 100644
--- a/JPratt/src/examples/java/bjc/pratt/examples/lang/BlockEnter.java
+++ b/JPratt/src/examples/java/bjc/pratt/examples/lang/BlockEnter.java
@@ -3,14 +3,14 @@ package bjc.pratt.examples.lang;
 import java.util.function.UnaryOperator;
 
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.esodata.Directory;
 import bjc.esodata.Stack;
 
 final class BlockEnter implements UnaryOperator<TestContext> {
 	@Override
 	public TestContext apply(final TestContext state) {
-		final Directory<String, ITree<Token<String, String>>> enclosing = state.scopes.top();
+		final Directory<String, Tree<Token<String, String>>> enclosing = state.scopes.top();
 		final Stack<Integer> blockCount = state.blockCount;
 
 		final int currBlockNumber = blockCount.pop();
diff --git a/JPratt/src/examples/java/bjc/pratt/examples/lang/PrattParserTest.java b/JPratt/src/examples/java/bjc/pratt/examples/lang/PrattParserTest.java
index 8bebb1a..15c0b81 100644
--- a/JPratt/src/examples/java/bjc/pratt/examples/lang/PrattParserTest.java
+++ b/JPratt/src/examples/java/bjc/pratt/examples/lang/PrattParserTest.java
@@ -31,9 +31,9 @@ import bjc.pratt.commands.NonInitialCommand;
 import bjc.pratt.tokens.StringToken;
 import bjc.pratt.tokens.StringTokenStream;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.data.TransformIterator;
-import bjc.funcdata.IList;
+import bjc.funcdata.ListEx;
 import bjc.utils.parserutils.ParserException;
 import bjc.utils.parserutils.splitter.ConfigurableTokenSplitter;
 import bjc.utils.parserutils.splitter.ExcludingTokenSplitter;
@@ -142,7 +142,7 @@ public class PrattParserTest {
 				 */
 				tokenStream.next();
 
-				final ITree<Token<String, String>> rawTree = parser.parseExpression(0, tokenStream, ctx, true);
+				final Tree<Token<String, String>> rawTree = parser.parseExpression(0, tokenStream, ctx, true);
 
 				if (!tokenStream.headIs("(end)")) {
 					System.out.println("\nMultiple expressions on line");
@@ -185,7 +185,7 @@ public class PrattParserTest {
 			String strang = raw.replaceAll("\\.(\\.+)", "$1");
 			
 			if (doSplit) {	
-				IList<String> splitStrangs = split.split(strang);
+				ListEx<String> splitStrangs = split.split(strang);
 				splitStrangs.removeMatching("");
 
 				splitStrangs.forEach(splitTokens::add);
diff --git a/JPratt/src/examples/java/bjc/pratt/examples/lang/SwitchCommand.java b/JPratt/src/examples/java/bjc/pratt/examples/lang/SwitchCommand.java
index 4ee778d..fb2ae66 100644
--- a/JPratt/src/examples/java/bjc/pratt/examples/lang/SwitchCommand.java
+++ b/JPratt/src/examples/java/bjc/pratt/examples/lang/SwitchCommand.java
@@ -4,18 +4,18 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.commands.InitialCommand;
 import bjc.pratt.tokens.StringToken;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 class SwitchCommand implements InitialCommand<String, String, TestContext> {
 	@Override
-	public ITree<Token<String, String>> denote(final Token<String, String> operator,
+	public Tree<Token<String, String>> denote(final Token<String, String> operator,
 			final ParserContext<String, String, TestContext> ctx) throws ParserException {
-		final ITree<Token<String, String>> object = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
+		final Tree<Token<String, String>> object = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
 
-		final ITree<Token<String, String>> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
+		final Tree<Token<String, String>> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
 
-		return new Tree<>(new StringToken("switch", "switch"), object, body);
+		return new SimpleTree<>(new StringToken("switch", "switch"), object, body);
 	}
 }
diff --git a/JPratt/src/examples/java/bjc/pratt/examples/lang/TestContext.java b/JPratt/src/examples/java/bjc/pratt/examples/lang/TestContext.java
index 7db91e7..b0713ae 100644
--- a/JPratt/src/examples/java/bjc/pratt/examples/lang/TestContext.java
+++ b/JPratt/src/examples/java/bjc/pratt/examples/lang/TestContext.java
@@ -1,7 +1,7 @@
 package bjc.pratt.examples.lang;
 
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.esodata.Directory;
 import bjc.esodata.SimpleDirectory;
 import bjc.esodata.SimpleStack;
@@ -17,7 +17,7 @@ public class TestContext {
 	/**
 	 * The variable scoping information.
 	 */
-	public Stack<Directory<String, ITree<Token<String, String>>>> scopes;
+	public Stack<Directory<String, Tree<Token<String, String>>>> scopes;
 
 	/**
 	 * The current number of scopes inside this scope.
diff --git a/JPratt/src/examples/java/bjc/pratt/examples/lang/VarCommand.java b/JPratt/src/examples/java/bjc/pratt/examples/lang/VarCommand.java
index 6a1e3da..1f47218 100644
--- a/JPratt/src/examples/java/bjc/pratt/examples/lang/VarCommand.java
+++ b/JPratt/src/examples/java/bjc/pratt/examples/lang/VarCommand.java
@@ -4,14 +4,14 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.commands.AbstractInitialCommand;
 import bjc.pratt.tokens.StringToken;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 class VarCommand extends AbstractInitialCommand<String, String, TestContext> {
 
 	@Override
-	protected ITree<Token<String, String>> intNullDenotation(final Token<String, String> operator,
+	protected Tree<Token<String, String>> intNullDenotation(final Token<String, String> operator,
 			final ParserContext<String, String, TestContext> ctx) throws ParserException {
 		final Token<String, String> name = ctx.tokens.current();
 
@@ -26,11 +26,11 @@ class VarCommand extends AbstractInitialCommand<String, String, TestContext> {
 
 		ctx.tokens.expect(":=");
 
-		final ITree<Token<String, String>> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
+		final Tree<Token<String, String>> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false);
 
 		ctx.state.scopes.top().putKey(name.getValue(), body);
 
-		return new Tree<>(new StringToken("var-bind", "var-bind"), new Tree<>(name), body);
+		return new SimpleTree<>(new StringToken("var-bind", "var-bind"), new SimpleTree<>(name), body);
 	}
 
 }
diff --git a/JPratt/src/main/java/bjc/pratt/PrattParser.java b/JPratt/src/main/java/bjc/pratt/PrattParser.java
index 1834b7d..9887aa0 100644
--- a/JPratt/src/main/java/bjc/pratt/PrattParser.java
+++ b/JPratt/src/main/java/bjc/pratt/PrattParser.java
@@ -11,7 +11,7 @@ import bjc.pratt.commands.impls.DefaultInitialCommand;
 import bjc.pratt.commands.impls.DefaultNonInitialCommand;
 import bjc.pratt.tokens.Token;
 import bjc.pratt.tokens.TokenStream;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.funcutils.NumberUtils;
 import bjc.utils.parserutils.ParserException;
 
@@ -99,7 +99,7 @@ public class PrattParser<K, V, C> {
 	 * @throws ParserException
 	 *         If something goes wrong during parsing.
 	 */
-	public ITree<Token<K, V>> parseExpression(final int precedence, final TokenStream<K, V> tokens, final C state,
+	public Tree<Token<K, V>> parseExpression(final int precedence, final TokenStream<K, V> tokens, final C state,
 			final boolean isStatement) throws ParserException {
 		if(precedence < 0) throw new IllegalArgumentException("Precedence must be greater than zero");
 
@@ -111,7 +111,7 @@ public class PrattParser<K, V, C> {
 		final K initKey = initToken.getKey();
 
 		InitialCommand<K, V, C> nullCommand = getInitialCommand(isStatement, initKey, parserContext);
-		ITree<Token<K, V>> ast = nullCommand.denote(initToken, parserContext);
+		Tree<Token<K, V>> ast = nullCommand.denote(initToken, parserContext);
 
 		parserContext.initial = initKey;
 
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
index 434b47f..038b6ea 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
@@ -4,8 +4,8 @@ import java.util.Set;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -51,19 +51,19 @@ public class ChainParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException {
-		ITree<Token<K, V>> expression = iner.parse(ctx);
+	public Tree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException {
+		Tree<Token<K, V>> expression = iner.parse(ctx);
 
 		Token<K, V> currentToken = ctx.tokens.current();
 		if(indicators.contains(currentToken.getKey())) {
-			ITree<Token<K, V>> res = new Tree<>(trm);
+			Tree<Token<K, V>> res = new SimpleTree<>(trm);
 			res.addChild(expression);
 
 			while(indicators.contains(currentToken.getKey())) {
-				res.addChild(new Tree<>(currentToken));
+				res.addChild(new SimpleTree<>(currentToken));
 				ctx.tokens.next();
 
-				ITree<Token<K, V>> innerExpression = iner.parse(ctx);
+				Tree<Token<K, V>> innerExpression = iner.parse(ctx);
 				res.addChild(innerExpression);
 
 				currentToken = ctx.tokens.current();
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
index 0b1fb36..2432d6e 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
@@ -6,7 +6,7 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.PrattParser;
 import bjc.pratt.tokens.Token;
 import bjc.pratt.tokens.TokenStream;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.functypes.*;
 import bjc.utils.parserutils.ParserException;
 
@@ -41,7 +41,7 @@ public class GrammarParseBlock<K, V, C, K2, V2, C2> implements ParseBlock<K, V,
 
 	private final Function<TokenStream<K, V>, TokenStream<K2, V2>> tkenTransform;
 	private final Isomorphism<C, C2> stteTransform;
-	private final Function<ITree<Token<K2, V2>>, ITree<Token<K, V>>> xpressionTransform;
+	private final Function<Tree<Token<K2, V2>>, Tree<Token<K, V>>> xpressionTransform;
 
 	/**
 	 * Create a new grammar parser block.
@@ -56,7 +56,7 @@ public class GrammarParseBlock<K, V, C, K2, V2, C2> implements ParseBlock<K, V,
 	public GrammarParseBlock(final PrattParser<K2, V2, C2> inner, final int precedence, final boolean isStatement,
 			final Function<TokenStream<K, V>, TokenStream<K2, V2>> tokenTransform,
 			final Isomorphism<C, C2> stateTransform,
-			final Function<ITree<Token<K2, V2>>, ITree<Token<K, V>>> expressionTransform) {
+			final Function<Tree<Token<K2, V2>>, Tree<Token<K, V>>> expressionTransform) {
 		innr = inner;
 		prcedence = precedence;
 		isStatemnt = isStatement;
@@ -66,12 +66,12 @@ public class GrammarParseBlock<K, V, C, K2, V2, C2> implements ParseBlock<K, V,
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
 		final C2 newState = stteTransform.to(ctx.state);
 
 		final TokenStream<K2, V2> newTokens = tkenTransform.apply(ctx.tokens);
 
-		final ITree<Token<K2, V2>> expression = innr.parseExpression(prcedence, newTokens, newState,
+		final Tree<Token<K2, V2>> expression = innr.parseExpression(prcedence, newTokens, newState,
 				isStatemnt);
 
 		ctx.state = stteTransform.from(newState);
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
index d6cfda9..81ba508 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
@@ -2,7 +2,7 @@ package bjc.pratt.blocks;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -34,6 +34,6 @@ public interface ParseBlock<K, V, C> {
 	 *         If something goes wrong during parsing, or the block fails
 	 *         validation.
 	 */
-	ITree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException;
+	Tree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException;
 
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java
index e0d63f3..96b9737 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java
@@ -4,7 +4,7 @@ import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 
 /**
  * Utility class for creating common implementations of {@link ParseBlock}
@@ -91,7 +91,7 @@ public class ParseBlocks {
 	 * @return A configured simple parse block.
 	 */
 	public static <K, V, C> ParseBlock<K, V, C> simple(final int precedence, final K terminator,
-			final Predicate<ITree<Token<K, V>>> validator) {
+			final Predicate<Tree<Token<K, V>>> validator) {
 		return new SimpleParseBlock<>(precedence, validator, terminator);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java
index fafccf1..4c21358 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java
@@ -4,8 +4,8 @@ import java.util.function.UnaryOperator;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -72,13 +72,13 @@ public class RepeatingParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
-		final ITree<Token<K, V>> ret = new Tree<>(mark);
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+		final Tree<Token<K, V>> ret = new SimpleTree<>(mark);
 
 		Token<K, V> tok = ctx.tokens.current();
 
 		while(!tok.getKey().equals(term)) {
-			final ITree<Token<K, V>> kid = innerBlock.parse(ctx);
+			final Tree<Token<K, V>> kid = innerBlock.parse(ctx);
 			ret.addChild(kid);
 
 			tok = ctx.tokens.current();
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
index 6dd925e..83e1d91 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
@@ -4,7 +4,7 @@ import java.util.function.Predicate;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -26,7 +26,7 @@ public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 
 	private final K term;
 
-	private final Predicate<ITree<Token<K, V>>> validatr;
+	private final Predicate<Tree<Token<K, V>>> validatr;
 
 	/**
 	 * Create a new block.
@@ -39,7 +39,7 @@ public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	 *        The token type that terminates the block. If this is null,
 	 *        don't check for a terminator.
 	 */
-	public SimpleParseBlock(final int precedence, final Predicate<ITree<Token<K, V>>> validator,
+	public SimpleParseBlock(final int precedence, final Predicate<Tree<Token<K, V>>> validator,
 			final K terminator) {
 		if(precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative");
 
@@ -49,8 +49,8 @@ public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
-		final ITree<Token<K, V>> res = ctx.parse.parseExpression(pow, ctx.tokens, ctx.state, false);
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+		final Tree<Token<K, V>> res = ctx.parse.parseExpression(pow, ctx.tokens, ctx.state, false);
 
 		if(term != null) {
 			ctx.tokens.expect(term);
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
index f29e3b7..bfe5ab3 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
@@ -4,7 +4,7 @@ import java.util.function.UnaryOperator;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -45,12 +45,12 @@ public class TriggeredParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
 		final C newState = onEntr.apply(ctx.state);
 
 		final ParserContext<K, V, C> newCtx = new ParserContext<>(ctx.tokens, ctx.parse, newState);
 
-		final ITree<Token<K, V>> res = sourc.parse(newCtx);
+		final Tree<Token<K, V>> res = sourc.parse(newCtx);
 
 		ctx.state = onExt.apply(newState);
 
diff --git a/JPratt/src/main/java/bjc/pratt/commands/AbstractInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/AbstractInitialCommand.java
index 43abd96..50e884b 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/AbstractInitialCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/AbstractInitialCommand.java
@@ -2,7 +2,7 @@ package bjc.pratt.commands;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -21,7 +21,7 @@ import bjc.utils.parserutils.ParserException;
  */
 public abstract class AbstractInitialCommand<K, V, C> implements InitialCommand<K, V, C> {
 	@Override
-	public ITree<Token<K, V>> denote(final Token<K, V> operator,
+	public Tree<Token<K, V>> denote(final Token<K, V> operator,
 			final ParserContext<K, V, C> ctx) throws ParserException {
 		return intNullDenotation(operator, ctx);
 	}
@@ -39,7 +39,7 @@ public abstract class AbstractInitialCommand<K, V, C> implements InitialCommand<
 	 * @throws ParserException
 	 *                         If something went wrong while parsing.
 	 */
-	protected abstract ITree<Token<K, V>> intNullDenotation(Token<K, V> operator,
+	protected abstract Tree<Token<K, V>> intNullDenotation(Token<K, V> operator,
 			ParserContext<K, V, C> ctx) throws ParserException;
 
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/BinaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/BinaryCommand.java
index 0b790ff..069de78 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/BinaryCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/BinaryCommand.java
@@ -2,8 +2,8 @@ package bjc.pratt.commands;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -39,12 +39,12 @@ public abstract class BinaryCommand<K, V, C> extends BinaryPostCommand<K, V, C>
 	protected abstract int rightBinding();
 
 	@Override
-	public ITree<Token<K, V>> denote(final ITree<Token<K, V>> operand,
+	public Tree<Token<K, V>> denote(final Tree<Token<K, V>> operand,
 			final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
-		final ITree<Token<K, V>> opr
+		final Tree<Token<K, V>> opr
 				= ctx.parse.parseExpression(rightBinding(), ctx.tokens, ctx.state, false);
 
-		return new Tree<>(operator, operand, opr);
+		return new SimpleTree<>(operator, operand, opr);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/InitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/InitialCommand.java
index 4a8a93b..3a2a8ff 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/InitialCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/InitialCommand.java
@@ -2,7 +2,7 @@ package bjc.pratt.commands;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -36,5 +36,5 @@ public interface InitialCommand<K, V, C> {
 	 * @throws ParserException
 	 *         If something goes wrong during parsing.
 	 */
-	ITree<Token<K, V>> denote(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException;
+	Tree<Token<K, V>> denote(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException;
 }
diff --git a/JPratt/src/main/java/bjc/pratt/commands/NonInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/NonInitialCommand.java
index c73874e..12eecb6 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/NonInitialCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/NonInitialCommand.java
@@ -2,7 +2,7 @@ package bjc.pratt.commands;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -37,7 +37,7 @@ public abstract class NonInitialCommand<K, V, C> {
 	 * @throws ParserException
 	 *         If something went wrong during parsing.
 	 */
-	public abstract ITree<Token<K, V>> denote(ITree<Token<K, V>> operand, Token<K, V> operator,
+	public abstract Tree<Token<K, V>> denote(Tree<Token<K, V>> operand, Token<K, V> operator,
 			ParserContext<K, V, C> ctx) throws ParserException;
 
 	/**
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/BlockInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/BlockInitialCommand.java
index b462118..db11484 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/BlockInitialCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/BlockInitialCommand.java
@@ -4,7 +4,7 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.blocks.ParseBlock;
 import bjc.pratt.commands.AbstractInitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -35,7 +35,7 @@ public class BlockInitialCommand<K, V, C> extends AbstractInitialCommand<K, V, C
 	}
 
 	@Override
-	protected ITree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	protected Tree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
 		return blck.parse(ctx);
 	}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/ChainCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/ChainCommand.java
index 0397a19..ed7a088 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/ChainCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/ChainCommand.java
@@ -5,8 +5,8 @@ import java.util.Set;
 import bjc.pratt.ParserContext;
 import bjc.pratt.commands.BinaryPostCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -48,21 +48,21 @@ public class ChainCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> denote(final ITree<Token<K, V>> operand, final Token<K, V> operator,
+	public Tree<Token<K, V>> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
 			final ParserContext<K, V, C> ctx) throws ParserException {
-		final ITree<Token<K, V>> tree = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state,
+		final Tree<Token<K, V>> tree = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state,
 				false);
 
-		final ITree<Token<K, V>> res = new Tree<>(operator, operand, tree);
+		final Tree<Token<K, V>> res = new SimpleTree<>(operator, operand, tree);
 
 		if(chainWith.contains(ctx.tokens.current().getKey())) {
 			final Token<K, V> tok = ctx.tokens.current();
 			ctx.tokens.next();
 
-			final ITree<Token<K, V>> other = denote(tree, tok,
+			final Tree<Token<K, V>> other = denote(tree, tok,
 					new ParserContext<>(ctx.tokens, ctx.parse, ctx.state));
 
-			return new Tree<>(chain, res, other);
+			return new SimpleTree<>(chain, res, other);
 		}
 
 		return res;
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/ConstantCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/ConstantCommand.java
index dc1b206..409adbb 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/ConstantCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/ConstantCommand.java
@@ -3,7 +3,7 @@ package bjc.pratt.commands.impls;
 import bjc.pratt.ParserContext;
 import bjc.pratt.commands.InitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -21,7 +21,7 @@ import bjc.utils.parserutils.ParserException;
  *        The state type of the parser.
  */
 public class ConstantCommand<K, V, C> implements InitialCommand<K, V, C> {
-	private final ITree<Token<K, V>> val;
+	private final Tree<Token<K, V>> val;
 
 	/**
 	 * Create a new constant.
@@ -29,12 +29,12 @@ public class ConstantCommand<K, V, C> implements InitialCommand<K, V, C> {
 	 * @param con
 	 *        The tree this constant represents.
 	 */
-	public ConstantCommand(final ITree<Token<K, V>> con) {
+	public ConstantCommand(final Tree<Token<K, V>> con) {
 		val = con;
 	}
 
 	@Override
-	public ITree<Token<K, V>> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	public Tree<Token<K, V>> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
 		return val;
 	}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultInitialCommand.java
index 6f0e4d5..296cb1c 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultInitialCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultInitialCommand.java
@@ -3,7 +3,7 @@ package bjc.pratt.commands.impls;
 import bjc.pratt.ParserContext;
 import bjc.pratt.commands.InitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -22,7 +22,7 @@ import bjc.utils.parserutils.ParserException;
  */
 public class DefaultInitialCommand<K, V, C> implements InitialCommand<K, V, C> {
 	@Override
-	public ITree<Token<K, V>> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	public Tree<Token<K, V>> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
 		throw new ParserException("Unexpected token " + operator);
 	}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultNonInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultNonInitialCommand.java
index 77cce6e..797473a 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultNonInitialCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultNonInitialCommand.java
@@ -3,7 +3,7 @@ package bjc.pratt.commands.impls;
 import bjc.pratt.ParserContext;
 import bjc.pratt.commands.NonInitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 
 /**
  * Default implementation of a non-initial command.
@@ -21,7 +21,7 @@ import bjc.data.ITree;
  */
 public class DefaultNonInitialCommand<K, V, C> extends NonInitialCommand<K, V, C> {
 	@Override
-	public ITree<Token<K, V>> denote(final ITree<Token<K, V>> operand, final Token<K, V> operator,
+	public Tree<Token<K, V>> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
 			final ParserContext<K, V, C> ctx) {
 		throw new UnsupportedOperationException("Default command has no left denotation");
 	}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/DenestingCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/DenestingCommand.java
index f6a84f6..fbcd35c 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/DenestingCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/DenestingCommand.java
@@ -4,7 +4,7 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.commands.AbstractInitialCommand;
 import bjc.pratt.commands.InitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -39,7 +39,7 @@ public class DenestingCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
 	}
 
 	@Override
-	protected ITree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	protected Tree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
 		return wrapped.denote(operator, ctx).getChild(0);
 	}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/GroupingCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/GroupingCommand.java
index 82f7eaa..1515359 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/GroupingCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/GroupingCommand.java
@@ -4,8 +4,8 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.blocks.ParseBlock;
 import bjc.pratt.commands.AbstractInitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -43,10 +43,10 @@ public class GroupingCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
 	}
 
 	@Override
-	protected ITree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	protected Tree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
-		final ITree<Token<K, V>> opr = innerBlock.parse(ctx);
+		final Tree<Token<K, V>> opr = innerBlock.parse(ctx);
 
-		return new Tree<>(mark, opr);
+		return new SimpleTree<>(mark, opr);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java b/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java
index dc8009e..8a9108b 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java
@@ -9,7 +9,7 @@ import java.util.function.UnaryOperator;
 import bjc.pratt.blocks.ParseBlock;
 import bjc.pratt.commands.InitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 
 /**
  * * Contains factory methods for producing common implementations of
@@ -121,7 +121,7 @@ public class InitialCommands {
 	 *
 	 * @return A command implementing the constant.
 	 */
-	public static <K, V, C> InitialCommand<K, V, C> constant(final ITree<Token<K, V>> val) {
+	public static <K, V, C> InitialCommand<K, V, C> constant(final Tree<Token<K, V>> val) {
 		return new ConstantCommand<>(val);
 	}
 
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/LeafCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/LeafCommand.java
index fd535fa..1223641 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/LeafCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/LeafCommand.java
@@ -3,8 +3,8 @@ package bjc.pratt.commands.impls;
 import bjc.pratt.ParserContext;
 import bjc.pratt.commands.InitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -23,8 +23,8 @@ import bjc.utils.parserutils.ParserException;
  */
 public class LeafCommand<K, V, C> implements InitialCommand<K, V, C> {
 	@Override
-	public ITree<Token<K, V>> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	public Tree<Token<K, V>> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
-		return new Tree<>(operator);
+		return new SimpleTree<>(operator);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/PostCircumfixCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/PostCircumfixCommand.java
index cd13342..78ac1ef 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/PostCircumfixCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/PostCircumfixCommand.java
@@ -4,8 +4,8 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.blocks.ParseBlock;
 import bjc.pratt.commands.BinaryPostCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -50,10 +50,10 @@ public class PostCircumfixCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> denote(final ITree<Token<K, V>> operand, final Token<K, V> operator,
+	public Tree<Token<K, V>> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
 			final ParserContext<K, V, C> ctx) throws ParserException {
-		final ITree<Token<K, V>> inside = innerBlock.parse(ctx);
+		final Tree<Token<K, V>> inside = innerBlock.parse(ctx);
 
-		return new Tree<>(mark, operand, inside);
+		return new SimpleTree<>(mark, operand, inside);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/PostfixCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/PostfixCommand.java
index edea7e7..da587c1 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/PostfixCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/PostfixCommand.java
@@ -3,8 +3,8 @@ package bjc.pratt.commands.impls;
 import bjc.pratt.ParserContext;
 import bjc.pratt.commands.BinaryPostCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -33,8 +33,8 @@ public class PostfixCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> denote(final ITree<Token<K, V>> operand, final Token<K, V> operator,
+	public Tree<Token<K, V>> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
 			final ParserContext<K, V, C> ctx) throws ParserException {
-		return new Tree<>(operator, operand);
+		return new SimpleTree<>(operator, operand);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/PreTernaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/PreTernaryCommand.java
index 0a7c8ff..e315804 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/PreTernaryCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/PreTernaryCommand.java
@@ -4,8 +4,8 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.blocks.ParseBlock;
 import bjc.pratt.commands.AbstractInitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -63,14 +63,14 @@ public class PreTernaryCommand<K, V, C> extends AbstractInitialCommand<K, V, C>
 	}
 
 	@Override
-	protected ITree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	protected Tree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
-		final ITree<Token<K, V>> cond = condBlock.parse(ctx);
+		final Tree<Token<K, V>> cond = condBlock.parse(ctx);
 
-		final ITree<Token<K, V>> op1 = opblock1.parse(ctx);
+		final Tree<Token<K, V>> op1 = opblock1.parse(ctx);
 
-		final ITree<Token<K, V>> op2 = opblock2.parse(ctx);
+		final Tree<Token<K, V>> op2 = opblock2.parse(ctx);
 
-		return new Tree<>(trm, cond, op1, op2);
+		return new SimpleTree<>(trm, cond, op1, op2);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java
index f4744a7..174f6fb 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java
@@ -4,8 +4,8 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.blocks.ParseBlock;
 import bjc.pratt.commands.BinaryPostCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -58,14 +58,14 @@ public class TernaryCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> denote(final ITree<Token<K, V>> operand, final Token<K, V> operator,
+	public Tree<Token<K, V>> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
 			final ParserContext<K, V, C> ctx) throws ParserException {
-		final ITree<Token<K, V>> inner = innerBlck.parse(ctx);
+		final Tree<Token<K, V>> inner = innerBlck.parse(ctx);
 
-		final ITree<Token<K, V>> outer = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state,
+		final Tree<Token<K, V>> outer = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state,
 				false);
 
-		return new Tree<>(mark, inner, operand, outer);
+		return new SimpleTree<>(mark, inner, operand, outer);
 	}
 
 	@Override
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/TransformingInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/TransformingInitialCommand.java
index 69eed45..d39ec90 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/TransformingInitialCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/TransformingInitialCommand.java
@@ -6,7 +6,7 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.commands.AbstractInitialCommand;
 import bjc.pratt.commands.InitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -26,7 +26,7 @@ import bjc.utils.parserutils.ParserException;
 public class TransformingInitialCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
 	private final InitialCommand<K, V, C> internl;
 
-	private final UnaryOperator<ITree<Token<K, V>>> transfrm;
+	private final UnaryOperator<Tree<Token<K, V>>> transfrm;
 
 	/**
 	 * Create a new transforming initial command.
@@ -38,14 +38,14 @@ public class TransformingInitialCommand<K, V, C> extends AbstractInitialCommand<
 	 *        The transform to apply to the returned tree.
 	 */
 	public TransformingInitialCommand(final InitialCommand<K, V, C> internal,
-			final UnaryOperator<ITree<Token<K, V>>> transform) {
+			final UnaryOperator<Tree<Token<K, V>>> transform) {
 		super();
 		internl = internal;
 		transfrm = transform;
 	}
 
 	@Override
-	protected ITree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	protected Tree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
 		return transfrm.apply(internl.denote(operator, ctx));
 	}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/UnaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/UnaryCommand.java
index 652dacd..2e7365b 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/UnaryCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/UnaryCommand.java
@@ -3,8 +3,8 @@ package bjc.pratt.commands.impls;
 import bjc.pratt.ParserContext;
 import bjc.pratt.commands.AbstractInitialCommand;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -37,10 +37,10 @@ public class UnaryCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
 	}
 
 	@Override
-	protected ITree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
+	protected Tree<Token<K, V>> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
 			throws ParserException {
-		final ITree<Token<K, V>> opr = ctx.parse.parseExpression(nullPwer, ctx.tokens, ctx.state, false);
+		final Tree<Token<K, V>> opr = ctx.parse.parseExpression(nullPwer, ctx.tokens, ctx.state, false);
 
-		return new Tree<>(operator, opr);
+		return new SimpleTree<>(operator, opr);
 	}
 }
\ No newline at end of file