Adapt to esodata changes

19 files changed, 64 insertions, 64 deletions

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