46 files changed, 0 insertions, 3167 deletions

diff --git a/JPratt/src/main/java/bjc/pratt/ParserContext.java b/JPratt/src/main/java/bjc/pratt/ParserContext.java
deleted file mode 100644
index 76cdf22..0000000
--- a/JPratt/src/main/java/bjc/pratt/ParserContext.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package bjc.pratt;
-
-import bjc.pratt.tokens.TokenStream;
-
-/**
- * Represents the contextual state passed to a command.
- *
- * @author EVE
- *
- * @param <K>
- *        The key type of the tokens.
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class ParserContext<K, V, C> {
-	/**
-	 * The source of tokens.
-	 */
-	public TokenStream<K, V> tokens;
-
-	/**
-	 * The parser for sub-expressions.
-	 */
-	public PrattParser<K, V, C> parse;
-
-	/**
-	 * The state of the parser.
-	 */
-	public C state;
-
-	/**
-	 * The initial command for the current expression.
-	 */
-	public K initial;
-
-	/**
-	 * Create a new parser context.
-	 *
-	 * @param tokns
-	 *        The source of tokens.
-	 *
-	 * @param prse
-	 *        The parser to call for sub expressions.
-	 *
-	 * @param stte
-	 *        Any state needing to be kept during parsing.
-	 */
-	public ParserContext(final TokenStream<K, V> tokns, final PrattParser<K, V, C> prse, final C stte) {
-		tokens = tokns;
-		parse = prse;
-		state = stte;
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/PrattParser.java b/JPratt/src/main/java/bjc/pratt/PrattParser.java
deleted file mode 100644
index c7d40fc..0000000
--- a/JPratt/src/main/java/bjc/pratt/PrattParser.java
+++ /dev/null
@@ -1,333 +0,0 @@
-package bjc.pratt;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.commands.InitialCommand;
-import bjc.pratt.commands.MetaInitialCommand;
-import bjc.pratt.commands.MetaNonInitialCommand;
-import bjc.pratt.commands.NonInitialCommand;
-import bjc.pratt.commands.impls.DefaultInitialCommand;
-import bjc.pratt.commands.impls.DefaultNonInitialCommand;
-import bjc.pratt.tokens.ExpectionNotMet;
-import bjc.pratt.tokens.Token;
-import bjc.pratt.tokens.TokenStream;
-import bjc.data.TransformIterator;
-import bjc.data.Tree;
-import bjc.utils.funcutils.NumberUtils;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A configurable Pratt parser for expressions.
- *
- * @author EVE
- *
- * @param <K> The key type for the tokens.
- *
- * @param <V> The value type for the tokens.
- *
- * @param <C> The state type of the parser.
- *
- *
- */
-public class PrattParser<K, V, C> {
-	/*
-	 * Default commands that error when used.
-	 */
-	private final NonInitialCommand<K, V, C> DEFAULT_LEFT_COMMAND = new DefaultNonInitialCommand<>();
-	private final List<NonInitialCommand<K, V, C>> DEFAULT_LEFT_LIST = Arrays.asList(DEFAULT_LEFT_COMMAND);
-
-	private final InitialCommand<K, V, C> DEFAULT_NULL_COMMAND = new DefaultInitialCommand<>();
-	private final List<InitialCommand<K, V, C>> DEFAULT_NULL_LIST = Arrays.asList(DEFAULT_NULL_COMMAND);
-
-	/*
-	 * Left-commands that depend on what the null command was.
-	 */
-	private final Map<K, Map<K, List<NonInitialCommand<K, V, C>>>> dependantLeftCommands;
-	private final Map<K, Map<K, List<MetaNonInitialCommand<K, V, C>>>> dependantMetaLeftCommands;
-	/*
-	 * The left commands.
-	 */
-	private final Map<K, List<NonInitialCommand<K, V, C>>> leftCommands;
-	private final Map<K, List<MetaNonInitialCommand<K, V, C>>> metaLeftCommands;
-
-	/*
-	 * The initial commands.
-	 */
-	private final Map<K, List<InitialCommand<K, V, C>>> nullCommands;
-	private final Map<K, List<MetaInitialCommand<K, V, C>>> metaNullCommands;
-
-	/*
-	 * Initial commands only checked for statements.
-	 */
-	private final Map<K, List<InitialCommand<K, V, C>>> statementCommands;
-	private final Map<K, List<MetaInitialCommand<K, V, C>>> metaStatementCommands;
-
-	/**
-	 * Create a new Pratt parser.
-	 *
-	 */
-	public PrattParser() {
-		dependantLeftCommands = new HashMap<>();
-		dependantMetaLeftCommands = new HashMap<>();
-
-		leftCommands = new HashMap<>();
-		metaLeftCommands = new HashMap<>();
-
-		nullCommands = new HashMap<>();
-		metaNullCommands = new HashMap<>();
-
-		statementCommands = new HashMap<>();
-		metaStatementCommands = new HashMap<>();
-	}
-
-	/**
-	 * Parse an expression.
-	 *
-	 * @param precedence  The initial precedence for the expression.
-	 *
-	 * @param tokens      The tokens for the expression.
-	 *
-	 * @param state       The state of the parser.
-	 *
-	 * @param isStatement Whether or not to parse statements.
-	 *
-	 * @return The expression as an AST.
-	 *
-	 * @throws ParserException If something goes wrong during parsing.
-	 */
-	public CommandResult<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");
-
-		ParserContext<K, V, C> parserContext = new ParserContext<>(tokens, this, state);
-
-		Tree<Token<K, V>> ast = null;
-		CommandResult<K, V> result;
-
-		tokens.mark();
-		final Token<K, V> initToken = tokens.current();
-		tokens.next();
-		tokens.mark();
-
-		final K initKey = initToken.getKey();
-		Iterator<InitialCommand<K, V, C>> nullCommandIter = getInitialCommand(isStatement, initKey, parserContext);
-		do {
-			if (!nullCommandIter.hasNext()) {
-				// Restore to the state we were in before we tried to parse this token.
-				// Need the commit because rollback doesn't remove marks
-				tokens.rollback();
-				tokens.commit();
-				tokens.rollback();
-				return CommandResult.backtrack();
-			}
-
-			InitialCommand<K, V, C> nullCommand = nullCommandIter.next();
-			try {
-				result = nullCommand.denote(initToken, parserContext);
-			} catch (ExpectionNotMet enm) {
-				// TODO: Should enm be used for something here?
-				result = CommandResult.backtrack();
-			}
-			switch (result.status) {
-			case SUCCESS:
-				ast = result.success();
-				break;
-			case FAIL:
-				return result;
-			case BACKTRACK:
-				tokens.rollback();
-				break;
-			default:
-				throw new IllegalStateException("Unhandled result status " + result.status);
-			}
-			parserContext.initial = initKey;
-		} while (result.status != Status.SUCCESS);
-		tokens.commit();
-		// Think this is right...
-		// Will get rid of all our active marks.
-		tokens.commit();
-
-		int rightPrec = Integer.MAX_VALUE;
-
-		outer: while (true) {
-			tokens.mark();
-			final Token<K, V> tok = tokens.current();
-
-			final K key = tok.getKey();
-
-			Iterator<NonInitialCommand<K, V, C>> leftCommandIter = getNonInitialCommand(key, parserContext);
-			do {
-				if (!leftCommandIter.hasNext()) {
-					// Restore to the state we were in before we tried to parse this token.
-					// Need the commit because rollback doesn't remove marks
-					tokens.rollback();
-					tokens.commit();
-					tokens.rollback();
-					return CommandResult.backtrack();
-				}
-
-				NonInitialCommand<K, V, C> leftCommand = leftCommandIter.next();
-				final int leftBind = leftCommand.leftBinding();
-
-				if (NumberUtils.between(precedence, rightPrec, leftBind)) {
-					tokens.next();
-					tokens.mark();
-
-					try {
-						result = leftCommand.denote(ast, tok, parserContext);
-						rightPrec = leftCommand.nextBinding();
-					} catch (ExpectionNotMet enm) {
-						result = CommandResult.backtrack();
-					}
-
-					switch (result.status) {
-					case SUCCESS:
-						tokens.commit();
-						tokens.commit();
-						ast = result.success();
-						break;
-					case FAIL:
-						return result;
-					case BACKTRACK:
-						tokens.rollback();
-						break;
-					default:
-						throw new IllegalStateException("Unhandled result status " + result.status);
-					}
-				} else {
-					tokens.commit();
-					break outer;
-				}
-			} while (result.status != Status.SUCCESS);
-		}
-
-		return CommandResult.success(ast);
-	}
-
-	/**
-	 * Add a non-initial command to this parser.
-	 *
-	 * @param marker The key that marks the command.
-	 *
-	 * @param comm   The command.
-	 */
-	public void addNonInitialCommand(final K marker, final NonInitialCommand<K, V, C> comm) {
-		leftCommands.computeIfAbsent(marker, mrk -> new ArrayList<>()).add(comm);
-	}
-
-	/**
-	 * Add a initial command to this parser.
-	 *
-	 * @param marker The key that marks the command.
-	 *
-	 * @param comm   The command.
-	 */
-	public void addInitialCommand(final K marker, final InitialCommand<K, V, C> comm) {
-		nullCommands.computeIfAbsent(marker, mrk -> new ArrayList<>()).add(comm);
-	}
-
-	/**
-	 * Add a statement command to this parser.
-	 *
-	 * The difference between statements and initial commands is that statements can
-	 * only appear at the start of the expression.
-	 *
-	 * @param marker The key that marks the command.
-	 *
-	 * @param comm   The command.
-	 */
-	public void addStatementCommand(final K marker, final InitialCommand<K, V, C> comm) {
-		statementCommands.computeIfAbsent(marker, mrk -> new ArrayList<>()).add(comm);
-	}
-
-	/**
-	 * Add a dependent non-initial command to this parser.
-	 *
-	 * @param dependant The dependent that precedes the command.
-	 *
-	 * @param marker    The token key that marks the command.
-	 *
-	 * @param comm      The command.
-	 */
-	public void addDependantCommand(final K dependant, final K marker, final NonInitialCommand<K, V, C> comm) {
-		Map<K, List<NonInitialCommand<K, V, C>>> dependantMap = dependantLeftCommands.getOrDefault(dependant,
-				new HashMap<>());
-
-		dependantMap.computeIfAbsent(marker, mrk -> new ArrayList<>()).add(comm);
-	}
-
-	/**
-	 * Lookup an initial command.
-	 * 
-	 * @param isStatement Whether to look for statement commands or not.
-	 * 
-	 * @param key         The key of the command.
-	 * 
-	 * @param ctx         The context for meta-commands.
-	 * 
-	 * @return A command attached to that key, or a default implementation.
-	 */
-	public Iterator<InitialCommand<K, V, C>> getInitialCommand(boolean isStatement, K key, ParserContext<K, V, C> ctx) {
-		if (isStatement) {
-			if (metaStatementCommands.containsKey(key)) {
-				List<MetaInitialCommand<K, V, C>> lst = metaStatementCommands.get(key);
-
-				return new TransformIterator<>(lst.iterator(), (itm) -> itm.getCommand(ctx));
-			} else if (statementCommands.containsKey(key)) {
-				return statementCommands.get(key).iterator();
-			}
-		}
-
-		if (metaNullCommands.containsKey(key)) {
-			List<MetaInitialCommand<K, V, C>> lst = metaNullCommands.get(key);
-
-			return new TransformIterator<>(lst.iterator(), (itm) -> itm.getCommand(ctx));
-		}
-
-		return nullCommands.getOrDefault(key, DEFAULT_NULL_LIST).iterator();
-	}
-
-	/**
-	 * Lookup a non-initial command.
-	 * 
-	 * @param key The key of the command.
-	 * 
-	 * @param ctx The context for meta-commands.
-	 * 
-	 * @return A command attached to that key, or a default implementation.
-	 */
-	public Iterator<NonInitialCommand<K, V, C>> getNonInitialCommand(K key, ParserContext<K, V, C> ctx) {
-		if (dependantMetaLeftCommands.containsKey(ctx.initial)) {
-			Map<K, List<MetaNonInitialCommand<K, V, C>>> dependantCommands = dependantMetaLeftCommands.get(ctx.initial);
-
-			if (dependantCommands.containsKey(key)) {
-				List<MetaNonInitialCommand<K, V, C>> lst = dependantCommands.get(key);
-
-				return new TransformIterator<>(lst.iterator(), (itm) -> itm.getCommand(ctx));
-			}
-		}
-
-		if (dependantLeftCommands.containsKey(ctx.initial)) {
-			Map<K, List<NonInitialCommand<K, V, C>>> dependantCommands = dependantLeftCommands.get(ctx.initial);
-
-			if (dependantCommands.containsKey(key)) {
-				return dependantCommands.getOrDefault(key, DEFAULT_LEFT_LIST).iterator();
-			}
-		}
-
-		if (metaLeftCommands.containsKey(key)) {
-			List<MetaNonInitialCommand<K, V, C>> lst = metaLeftCommands.get(key);
-			return new TransformIterator<>(lst.iterator(), (itm) -> itm.getCommand(ctx));
-		}
-
-		return leftCommands.getOrDefault(key, DEFAULT_LEFT_LIST).iterator();
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
deleted file mode 100644
index 2717e42..0000000
--- a/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
+++ /dev/null
@@ -1,85 +0,0 @@
-package bjc.pratt.blocks;
-
-import java.util.Set;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A {@link ParseBlock} for a series of parse blocks, linked by a set of tokens.
- * 
- * Roughly analogous to Perl 6s list associative operators.
- * 
- * @author bjculkin
- * 
- * @param <K>
- *        The token key type.
- * 
- * @param <V>
- *        The token value type.
- * 
- * @param <C>
- *        The parser state type.
- *
- */
-public class ChainParseBlock<K, V, C> implements ParseBlock<K, V, C> {
-	private ParseBlock<K, V, C> iner;
-
-	private Set<K> indicators;
-
-	private Token<K, V> trm;
-
-	/**
-	 * Create a new chain parser block.
-	 * 
-	 * @param inner
-	 *        The block for the chains interior.
-	 * 
-	 * @param chainIndicators
-	 *        The set of markers that indicate continuing the chain
-	 * 
-	 * @param term
-	 *        The node in the AST for the expression.
-	 */
-	public ChainParseBlock(ParseBlock<K, V, C> inner, Set<K> chainIndicators, Token<K, V> term) {
-		iner = inner;
-		indicators = chainIndicators;
-		trm = term;
-	}
-
-	@Override
-	public CommandResult<K, V> parse(ParserContext<K, V, C> ctx) throws ParserException {
-		CommandResult<K,V> resOuter = iner.parse(ctx);
-		if (resOuter.status != Status.SUCCESS) return resOuter;
-		
-		Tree<Token<K, V>> expression = resOuter.success();
-		Token<K, V> currentToken = ctx.tokens.current();
-		if(indicators.contains(currentToken.getKey())) {
-			Tree<Token<K, V>> res = new SimpleTree<>(trm);
-			res.addChild(expression);
-
-			while(indicators.contains(currentToken.getKey())) {
-				res.addChild(new SimpleTree<>(currentToken));
-				ctx.tokens.next();
-
-				CommandResult<K,V> resInner = iner.parse(ctx);
-				if (resInner.status != Status.SUCCESS) return resInner;
-				
-				Tree<Token<K, V>> innerExpression = resInner.success();
-				res.addChild(innerExpression);
-
-				currentToken = ctx.tokens.current();
-			}
-
-			return CommandResult.success(res);
-		}
-
-		return resOuter;
-	}
-
-}
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
deleted file mode 100644
index 446b80b..0000000
--- a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package bjc.pratt.blocks;
-
-import java.util.function.Function;
-
-import bjc.data.Tree;
-import bjc.pratt.ParserContext;
-import bjc.pratt.PrattParser;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.tokens.Token;
-import bjc.pratt.tokens.TokenStream;
-import bjc.typeclasses.Isomorphism;
-import bjc.data.Tree;
-import bjc.functypes.*;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A {@link ParseBlock} that parses an expression from a 'inner' grammar.
- *
- * @author bjculkin
- *
- * @param <K>  The key type of the outer tokens.
- *
- * @param <V>  The value type of the outer tokens.
- *
- * @param <C>  The state type of the outer parser.
- *
- * @param <K2> The key type of the inner tokens.
- *
- * @param <V2> The value type of the inner tokens.
- *
- * @param <C2> The state type of the outer parser.
- */
-public class GrammarParseBlock<K, V, C, K2, V2, C2> implements ParseBlock<K, V, C> {
-	private final PrattParser<K2, V2, C2> innr;
-
-	private final int prcedence;
-	private final boolean isStatemnt;
-
-	private final Function<TokenStream<K, V>, TokenStream<K2, V2>> tkenTransform;
-	private final Isomorphism<C, C2> stteTransform;
-	private final Function<Tree<Token<K2, V2>>, Tree<Token<K, V>>> xpressionTransform;
-
-	/**
-	 * Create a new grammar parser block.
-	 *
-	 * @param inner               The inner grammar to parse.
-	 * @param precedence          The precedence of the expression to parse.
-	 * @param isStatement         Is the expression being parsed in statement
-	 *                            context?
-	 * @param tokenTransform      Function to transform to the new token type.
-	 * @param stateTransform      Function to toggle between state types.
-	 * @param expressionTransform Function to transform back to the normal token
-	 *                            type.
-	 */
-	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<Tree<Token<K2, V2>>, Tree<Token<K, V>>> expressionTransform) {
-		innr = inner;
-		prcedence = precedence;
-		isStatemnt = isStatement;
-		tkenTransform = tokenTransform;
-		stteTransform = stateTransform;
-		xpressionTransform = expressionTransform;
-	}
-
-	@Override
-	public CommandResult<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 CommandResult<K2, V2> res = innr.parseExpression(prcedence, newTokens, newState, isStatemnt);
-		switch (res.status) {
-		case SUCCESS:
-			break;
-		case FAIL:
-			return CommandResult.fail();
-		case BACKTRACK:
-			return CommandResult.backtrack();
-		default:
-			throw new IllegalStateException("Unhandled status " + res.status);
-		}
-
-		Tree<Token<K2, V2>> expression = res.success();
-
-		ctx.state = stteTransform.from(newState);
-
-		return CommandResult.success(xpressionTransform.apply(expression));
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
deleted file mode 100644
index aa2fa2e..0000000
--- a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package bjc.pratt.blocks;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Represents a embedded block in an expression.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the token.
- *
- * @param <V>
- *        The value type of the token.
- *
- * @param <C>
- *        The state type of the parser.
- */
-@FunctionalInterface
-public interface ParseBlock<K, V, C> {
-
-	/**
-	 * Parse the block this represents.
-	 *
-	 * @param ctx
-	 *        The context for parsing.
-	 *
-	 * @return A AST for this block.
-	 *
-	 * @throws ParserException
-	 *         If something goes wrong during parsing, or the block fails
-	 *         validation.
-	 */
-	CommandResult<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
deleted file mode 100644
index 96b9737..0000000
--- a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java
+++ /dev/null
@@ -1,97 +0,0 @@
-package bjc.pratt.blocks;
-
-import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
-
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-
-/**
- * Utility class for creating common implementations of {@link ParseBlock}
- *
- * @author bjculkin
- *
- */
-public class ParseBlocks {
-	/*
-	 * Grammar parse blocks are complex enough to not get a builder method.
-	 */
-
-	/**
-	 * Create a new repeating parse block.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param inner
-	 *        The parse block to repeat.
-	 *
-	 * @param delim
-	 *        The token type that separates repetitions.
-	 *
-	 * @param term
-	 *        The token type that terminates repetitions.
-	 *
-	 * @param mark
-	 *        The token to use as the node in the AST.
-	 *
-	 * @param action
-	 *        The action to perform on the state after every repetition.
-	 *
-	 * @return A configured repeating parse block.
-	 */
-	public static <K, V, C> ParseBlock<K, V, C> repeating(final ParseBlock<K, V, C> inner, final K delim,
-			final K term, final Token<K, V> mark, final UnaryOperator<C> action) {
-		return new RepeatingParseBlock<>(inner, delim, term, mark, action);
-	}
-
-	/**
-	 * Create a new triggered parse block.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param source
-	 *        The block to trigger around.
-	 *
-	 * @param onEnter
-	 *        The action to perform upon the state before entering the
-	 *        block.
-	 *
-	 * @param onExit
-	 *        The action to perform upon the state after exiting the block.
-	 *
-	 * @return A configured trigger parse block.
-	 */
-	public static <K, V, C> ParseBlock<K, V, C> trigger(final ParseBlock<K, V, C> source,
-			final UnaryOperator<C> onEnter, final UnaryOperator<C> onExit) {
-		return new TriggeredParseBlock<>(onEnter, onExit, source);
-	}
-
-	/**
-	 * Create a new simple parse block.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the expression inside the block.
-	 *
-	 * @param terminator
-	 *        The key type of the token expected after this block, or null
-	 *        if none is expected.
-	 *
-	 * @param validator
-	 *        The predicate to use to validate parsed expressions, or null
-	 *        if none is used.
-	 *
-	 * @return A configured simple parse block.
-	 */
-	public static <K, V, C> ParseBlock<K, V, C> simple(final int precedence, final K terminator,
-			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
deleted file mode 100644
index 722e395..0000000
--- a/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java
+++ /dev/null
@@ -1,100 +0,0 @@
-package bjc.pratt.blocks;
-
-import java.util.function.UnaryOperator;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A parse block that can parse a sequnce of zero or more occurances of another
- * block.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class RepeatingParseBlock<K, V, C> implements ParseBlock<K, V, C> {
-	private final ParseBlock<K, V, C> innerBlock;
-
-	private final K delim;
-	private final K term;
-
-	private final UnaryOperator<C> onDelim;
-
-	private final Token<K, V> mark;
-
-	/**
-	 * Create a new repeating block.
-	 *
-	 * @param inner
-	 *        The inner block for elements.
-	 *
-	 * @param delimiter
-	 *        The token that delimits elements in the sequence.
-	 *
-	 * @param terminator
-	 *        The token that terminates the sequence.
-	 *
-	 * @param marker
-	 *        The token to use as the node in the AST.
-	 *
-	 * @param action
-	 *        The action to apply to the state after every delimiter.
-	 */
-	public RepeatingParseBlock(final ParseBlock<K, V, C> inner, final K delimiter, final K terminator,
-			final Token<K, V> marker, final UnaryOperator<C> action) {
-		super();
-
-		if(inner == null)
-			throw new NullPointerException("Inner block must not be null");
-		else if(delimiter == null)
-			throw new NullPointerException("Delimiter must not be null");
-		else if(terminator == null) throw new NullPointerException("Terminator must not be null");
-
-		innerBlock = inner;
-
-		delim = delimiter;
-		term = terminator;
-
-		mark = marker;
-
-		onDelim = action;
-	}
-
-	@Override
-	public CommandResult<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 CommandResult<K,V> resKid = innerBlock.parse(ctx);
-			if (resKid.status != Status.SUCCESS) return resKid;
-			Tree<Token<K, V>> kid = resKid.success();
-			ret.addChild(kid);
-
-			tok = ctx.tokens.current();
-
-			ctx.tokens.expect(delim, term);
-
-			if(onDelim != null) {
-				ctx.state = onDelim.apply(ctx.state);
-			}
-		}
-
-		return CommandResult.success(ret);
-	}
-
-}
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
deleted file mode 100644
index b674815..0000000
--- a/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
+++ /dev/null
@@ -1,97 +0,0 @@
-package bjc.pratt.blocks;
-
-import java.util.function.Predicate;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Simple implementation of {@link ParseBlock}
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
-	private final int pow;
-
-	private final K term;
-
-	private final Predicate<Tree<Token<K, V>>> validatr;
-
-	/**
-	 * Create a new block.
-	 *
-	 * @param precedence
-	 *        The precedence of this block.
-	 * @param validator
-	 *        The predicate to apply to blocks.
-	 * @param terminator
-	 *        The token type that terminates the block. If this is null,
-	 *        don't check for a terminator.
-	 */
-	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");
-
-		pow = precedence;
-		term = terminator;
-		validatr = validator;
-	}
-
-	@Override
-	public CommandResult<K, V> parse(final ParserContext<K, V, C> ctx) throws ParserException {
-		final CommandResult<K,V> resBlock = ctx.parse.parseExpression(pow, ctx.tokens, ctx.state, false);
-		if (resBlock.status != Status.SUCCESS) return resBlock;
-		
-		Tree<Token<K, V>> res = resBlock.success();
-		if(term != null) {
-			ctx.tokens.expect(term);
-		}
-
-		if(validatr == null || validatr.test(res)) return CommandResult.success(res);
-
-		// TODO: Figure out the right way to handle error context w/ CommandResult
-		throw new ParserException("Block failed validation");
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-
-		int result = 1;
-
-		result = prime * result + pow;
-		result = prime * result + (term == null ? 0 : term.hashCode());
-
-		return result;
-	}
-
-	@Override
-	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof SimpleParseBlock)) return false;
-
-		final SimpleParseBlock<?, ?, ?> other = (SimpleParseBlock<?, ?, ?>) obj;
-
-		if(pow != other.pow) return false;
-
-		if(term == null) {
-			if(other.term != null) return false;
-		} else if(!term.equals(other.term)) return false;
-
-		return true;
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
deleted file mode 100644
index d404eea..0000000
--- a/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
+++ /dev/null
@@ -1,62 +0,0 @@
-package bjc.pratt.blocks;
-
-import java.util.function.UnaryOperator;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A parse block that can adjust the state before handling its context.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- * @param <V>
- *        The value type of the tokens.
- * @param <C>
- *        The state type of the parser.
- */
-public class TriggeredParseBlock<K, V, C> implements ParseBlock<K, V, C> {
-	private final UnaryOperator<C> onEntr;
-	private final UnaryOperator<C> onExt;
-
-	private final ParseBlock<K, V, C> sourc;
-
-	/**
-	 * Create a new triggered parse block.
-	 *
-	 * @param onEnter
-	 *        The action to fire before parsing the block.
-	 *
-	 * @param onExit
-	 *        The action to fire after parsing the block.
-	 *
-	 * @param source
-	 *        The block to use for parsing.
-	 */
-	public TriggeredParseBlock(final UnaryOperator<C> onEnter, final UnaryOperator<C> onExit,
-			final ParseBlock<K, V, C> source) {
-		onEntr = onEnter;
-		onExt = onExit;
-		sourc = source;
-	}
-
-	@Override
-	public CommandResult<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 CommandResult<K,V> res = sourc.parse(newCtx);
-
-		if (res.status != Status.SUCCESS) return res;
-		
-		ctx.state = onExt.apply(newState);
-
-		return res;
-	}
-
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/AbstractInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/AbstractInitialCommand.java
deleted file mode 100644
index 3e4f3a9..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/AbstractInitialCommand.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package bjc.pratt.commands;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.tokens.Token;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Abstract base for initial commands.
- *
- * @author bjculkin
- *
- * @param <K>
- *            The key type of the tokens.
- *
- * @param <V>
- *            The value type of the tokens.
- *
- * @param <C>
- *            The state type of the parser.
- */
-public abstract class AbstractInitialCommand<K, V, C> implements InitialCommand<K, V, C> {
-	@Override
-	public CommandResult<K, V> denote(final Token<K, V> operator,
-			final ParserContext<K, V, C> ctx) throws ParserException {
-		return intNullDenotation(operator, ctx);
-	}
-
-	/**
-	 * Internal null denotation method.
-	 * 
-	 * @param operator
-	 *                 The operator that was parsed.
-	 * @param ctx
-	 *                 The parser context at this point.
-	 * 
-	 * @return The tree that this method parsed.
-	 * 
-	 * @throws ParserException
-	 *                         If something went wrong while parsing.
-	 */
-	protected abstract CommandResult<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
deleted file mode 100644
index 7a65052..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/BinaryCommand.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package bjc.pratt.commands;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A binary operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *            The key type of the tokens.
- *
- * @param <V>
- *            The value type of the tokens.
- *
- * @param <C>
- *            The state type of the parser.
- */
-public abstract class BinaryCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
-	/**
-	 * Create a new binary operator with the specified precedence.
-	 *
-	 * @param precedence
-	 *                   The precedence of the operator.
-	 */
-	public BinaryCommand(final int precedence) {
-		super(precedence);
-	}
-
-	/**
-	 * The right-binding power (right-precedence) of this command.
-	 * 
-	 * @return The right binding power of this command.
-	 */
-	protected abstract int rightBinding();
-
-	@Override
-	public CommandResult<K, V> denote(final Tree<Token<K, V>> operand,
-			final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		final CommandResult<K,V> opr
-				= ctx.parse.parseExpression(rightBinding(), ctx.tokens, ctx.state, false);
-		
-		if (opr.status != Status.SUCCESS) return opr;
-
-		return CommandResult.success(new SimpleTree<>(operator, operand, opr.success()));
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/BinaryPostCommand.java b/JPratt/src/main/java/bjc/pratt/commands/BinaryPostCommand.java
deleted file mode 100644
index 1fa1ba3..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/BinaryPostCommand.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package bjc.pratt.commands;
-
-/**
- * A operator with fixed precedence.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public abstract class BinaryPostCommand<K, V, C> extends NonInitialCommand<K, V, C> {
-	private final int leftPower;
-
-	/**
-	 * Create a new operator with fixed precedence.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 */
-	public BinaryPostCommand(final int precedence) {
-		if(precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative");
-
-		leftPower = precedence;
-	}
-
-	@Override
-	public int leftBinding() {
-		return leftPower;
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/BranchInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/BranchInitialCommand.java
deleted file mode 100644
index 3f3093e..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/BranchInitialCommand.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package bjc.pratt.commands;
-
-import java.util.Map;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.tokens.Token;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Represents a initial command that has a number of 'sub-commands' in the way that Go/Git CLI does.
- * 
- * @author bjcul
- *
- * @param <K> Token key type
- * @param <V> Token value type
- * @param <C> Parser context type
- */
-public class BranchInitialCommand<K, V, C> implements InitialCommand<K, V, C> {
-	private Map<K, InitialCommand<K, V, C>> comMap;
-	
-	/**
-	 * Create a new branch initial command
-	 * 
-	 * @param mep The map containing the commands
-	 */
-	public BranchInitialCommand(Map<K, InitialCommand<K, V, C>> mep) {
-		this.comMap = mep;
-	}
-	
-	@Override
-	public CommandResult<K, V> denote(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException {
-		Token<K, V> curToken = ctx.tokens.current();
-		ctx.tokens.expect(comMap.keySet());
-		
-		return comMap.get(curToken.getKey()).denote(curToken, ctx);
-	}
-
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/CommandResult.java b/JPratt/src/main/java/bjc/pratt/commands/CommandResult.java
deleted file mode 100644
index 38a55ae..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/CommandResult.java
+++ /dev/null
@@ -1,112 +0,0 @@
-package bjc.pratt.commands;
-
-import bjc.data.Tree;
-import bjc.pratt.tokens.Token;
-
-/**
- * Represents the result of executing a command.
- * 
- * @author bjcul
- *
- * @param <K> The key type of the tokens
- * @param <V> The value type of the tokens
- */
-public class CommandResult<K, V> {
-	/**
-	 * Represents the status of a command execution
-	 * 
-	 * @author bjcul
-	 *
-	 */
-	public static enum Status {
-		/**
-		 * The command successfully parsed.
-		 */
-		SUCCESS,
-		/**
-		 * The command failed, in a non-recoverable way
-		 */
-		FAIL,
-		/**
-		 * The command failed. Attempt recovery via backtracking
-		 */
-		BACKTRACK
-	}
-
-	/**
-	 * The status of this command.
-	 */
-	public final Status status;
-	
-	private Tree<Token<K, V>> success;
-	
-	private CommandResult(Status status) {
-		this.status = status;
-	}
-
-	/**
-	 * Get the success value of this command, or null if it failed.
-	 * 
-	 * @return The success value of the command
-	 */
-	public Tree<Token<K, V>> success() {
-		return success;
-	}
-
-	/**
-	 * Create a success result
-	 * 
-	 * @param <K2> The key type of the token
-	 * @param <V2> The value type of the token
-	 * 
-	 * @param succ The tree produced by the command
-	 * 
-	 * @return A command result representing a success
-	 */
-	public static <K2, V2> CommandResult<K2, V2> success(Tree<Token<K2, V2>> succ) {
-		CommandResult<K2, V2> result = new CommandResult<>(Status.SUCCESS);
-		result.success = succ;
-		return result;
-	}
-
-	/**
-	 * Create a non-backtracking failure result.
-	 * 
-	 * @param <K2> The key type of the token
-	 * @param <V2> The value type of the token
-	 * 
-	 * @return A command result representing a non-backtracking fail
-	 */
-	public static <K2, V2> CommandResult<K2, V2> fail() {
-		CommandResult<K2, V2> result = new CommandResult<>(Status.FAIL);
-		return result;
-	}
-
-	/**
-	 * Create a backtracking failure result.
-	 * 
-	 * @param <K2> The key type of the token
-	 * @param <V2> The value type of the token
-	 * 
-	 * @return A command result representing a backtracking fail
-	 */
-	public static <K2, V2> CommandResult<K2, V2> backtrack() {
-		CommandResult<K2, V2> result = new CommandResult<>(Status.BACKTRACK);
-		return result;
-	}
-
-	@Override
-	public String toString() {
-		StringBuilder builder = new StringBuilder();
-		builder.append("CommandResult [status=");
-		builder.append(status);
-		if (status == Status.SUCCESS) {
-			builder.append(", success=");
-			builder.append(success);
-		}
-		builder.append("]");
-		return builder.toString();
-	}
-	
-	
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/InitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/InitialCommand.java
deleted file mode 100644
index 0cfa290..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/InitialCommand.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package bjc.pratt.commands;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.tokens.Token;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Represents an initial command in parsing.
- *
- * @author EVE
- *
- * @param <K>
- *        The key type for the tokens.
- *
- * @param <V>
- *        The value type for the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- *
- *
- */
-@FunctionalInterface
-public interface InitialCommand<K, V, C> {
-	/**
-	 * Construct the null denotation of this command.
-	 *
-	 * @param operator
-	 *        The operator for this command.
-	 * @param ctx
-	 *        The context for the command.
-	 *
-	 * @return The result of executing the command.
-	 *
-	 * @throws ParserException
-	 *         If something goes wrong during parsing.
-	 */
-	CommandResult<K, V> denote(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException;
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/MetaInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/MetaInitialCommand.java
deleted file mode 100644
index d209177..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/MetaInitialCommand.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package bjc.pratt.commands;

-

-import bjc.pratt.ParserContext;

-

-/**

- * A 'meta-command' that yields the actual command to use.

- * 

- * @author bjculkin

- * 

- * @param <K>

- *            The key type of the context.

- * @param <V>

- *            The value type of the context.

- * @param <C>

- *            The storage type of the context.

- *

- */

-public interface MetaInitialCommand<K, V, C> {

-	/**

-	 * Get the command to use.

-	 * 

-	 * @param ctx

-	 *            The current parser context.

-	 * @return The command to use.

-	 */

-	InitialCommand<K, V, C> getCommand(ParserContext<K, V, C> ctx);

-}

diff --git a/JPratt/src/main/java/bjc/pratt/commands/MetaNonInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/MetaNonInitialCommand.java
deleted file mode 100644
index 956dcec..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/MetaNonInitialCommand.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package bjc.pratt.commands;
-
-import bjc.pratt.ParserContext;
-
-/**
- * A 'meta-command' for non-initial commands.
- * 
- * @author bjculkin
- *
- * @param <K>
- *            The token key type.
- * 
- * @param <V>
- *            The token value type.
- * 
- * @param <C>
- *            The parser state type.
- */
-public interface MetaNonInitialCommand<K, V, C> {
-	/**
-	 * Get the command to use.
-	 * 
-	 * @param ctx
-	 *            The context to use.
-	 * @return The command to use.
-	 */
-	NonInitialCommand<K, V, C> getCommand(ParserContext<K, V, C> ctx);
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/NonInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/NonInitialCommand.java
deleted file mode 100644
index 02826a9..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/NonInitialCommand.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package bjc.pratt.commands;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Represents a non-initial command in parsing.
- *
- * @author EVE
- *
- * @param <K>
- *        The key type for the tokens.
- *
- * @param <V>
- *        The value type for the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- *
- */
-public abstract class NonInitialCommand<K, V, C> {
-	/**
-	 * Construct the left denotation of this command.
-	 *
-	 * @param operand
-	 *        The left-hand operand of this command.
-	 * @param operator
-	 *        The operator for this command.
-	 *
-	 * @param ctx
-	 *        The state needed for commands.
-	 *
-	 * @return The result of executing the command.
-	 *
-	 * @throws ParserException
-	 *         If something went wrong during parsing.
-	 */
-	public abstract CommandResult<K, V> denote(Tree<Token<K, V>> operand, Token<K, V> operator,
-			ParserContext<K, V, C> ctx) throws ParserException;
-
-	/**
-	 * Get the left-binding power of this command.
-	 *
-	 * This represents the general precedence of this command.
-	 *
-	 * @return The left-binding power of this command.
-	 */
-	public abstract int leftBinding();
-
-	/**
-	 * Get the next-binding power of this command.
-	 *
-	 * This represents the highest precedence of command this command can be
-	 * the left operand of.
-	 *
-	 * This is the same as the left-binding power by default.
-	 *
-	 * @return The next-binding power of this command.
-	 */
-	public int nextBinding() {
-		return leftBinding();
-	}
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/BlockInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/BlockInitialCommand.java
deleted file mode 100644
index 07d9a76..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/BlockInitialCommand.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.blocks.ParseBlock;
-import bjc.pratt.commands.AbstractInitialCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.tokens.Token;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * An initial command that delegates all the work to a {@link ParseBlock}
- *
- * @author bjculkin
- * @param <K>
- *        The token key type.
- *
- * @param <V>
- *        The token value type.
- *
- * @param <C>
- *        The parser state type.
- *
- */
-public class BlockInitialCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
-	private final ParseBlock<K, V, C> blck;
-
-	/**
-	 * Create a new block initial command.
-	 *
-	 * @param block
-	 *        The block to delegate to.
-	 */
-	public BlockInitialCommand(final ParseBlock<K, V, C> block) {
-		blck = block;
-	}
-
-	@Override
-	protected CommandResult<K, V> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		return blck.parse(ctx);
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/ChainCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/ChainCommand.java
deleted file mode 100644
index 7311eb9..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/ChainCommand.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import java.util.Set;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.BinaryPostCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Create a new chained operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class ChainCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
-	private final Set<K> chainWith;
-
-	private final Token<K, V> chain;
-
-	/**
-	 * Create a new chained operator.
-	 *
-	 * @param precedence
-	 *        The precedence of this operator.
-	 *
-	 * @param chainSet
-	 *        The operators to chain with.
-	 *
-	 * @param chainMarker
-	 *        The token to use as the node in the AST.
-	 */
-	public ChainCommand(final int precedence, final Set<K> chainSet, final Token<K, V> chainMarker) {
-		super(precedence);
-
-		chainWith = chainSet;
-		chain = chainMarker;
-	}
-
-	@Override
-	public CommandResult<K, V> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
-			final ParserContext<K, V, C> ctx) throws ParserException {
-		CommandResult<K, V> resOuter = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state,
-				false);
-		if (resOuter.status != Status.SUCCESS) return resOuter;
-		final Tree<Token<K, V>> tree = resOuter.success();
-
-		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();
-
-			CommandResult<K, V> resOther = denote(tree, tok,
-					new ParserContext<>(ctx.tokens, ctx.parse, ctx.state));
-			if (resOther.status != Status.SUCCESS) return resOther;
-			
-			final Tree<Token<K, V>> other = resOther.success();
-
-			return CommandResult.success(new SimpleTree<>(chain, res, other));
-		}
-
-		return CommandResult.success(res);
-	}
-
-	@Override
-	public int nextBinding() {
-		return leftBinding() - 1;
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/ConstantCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/ConstantCommand.java
deleted file mode 100644
index 657743c..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/ConstantCommand.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.InitialCommand;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A command that represents a specific tree.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class ConstantCommand<K, V, C> implements InitialCommand<K, V, C> {
-	private final Tree<Token<K, V>> val;
-
-	/**
-	 * Create a new constant.
-	 *
-	 * @param con
-	 *        The tree this constant represents.
-	 */
-	public ConstantCommand(final Tree<Token<K, V>> con) {
-		val = con;
-	}
-
-	@Override
-	public CommandResult<K, V> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		return CommandResult.success(val);
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultInitialCommand.java
deleted file mode 100644
index 8d28b57..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultInitialCommand.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.InitialCommand;
-import bjc.pratt.tokens.Token;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Default implementation of an initial command.
- *
- * @author EVE
- *
- * @param <K>
- *        The key type of the token.
- *
- * @param <V>
- *        The value type of the token.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class DefaultInitialCommand<K, V, C> implements InitialCommand<K, V, C> {
-	@Override
-	public CommandResult<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
deleted file mode 100644
index 2ae9fb7..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/DefaultNonInitialCommand.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.NonInitialCommand;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-
-/**
- * Default implementation of a non-initial command.
- *
- * @author EVE
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class DefaultNonInitialCommand<K, V, C> extends NonInitialCommand<K, V, C> {
-	@Override
-	public CommandResult<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");
-	}
-
-	@Override
-	public int leftBinding() {
-		return -1;
-	}
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/DenestingCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/DenestingCommand.java
deleted file mode 100644
index de39e0b..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/DenestingCommand.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.AbstractInitialCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.commands.InitialCommand;
-import bjc.pratt.tokens.Token;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A command that denests a input tree.
- *
- * Useful for processing the result of passing a complex parse group to a
- * command.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- *
- */
-public class DenestingCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
-	private final InitialCommand<K, V, C> wrapped;
-
-	/**
-	 * Create a new transforming initial command.
-	 *
-	 * @param internal
-	 *        The initial command to delegate to.
-	 */
-	public DenestingCommand(final InitialCommand<K, V, C> internal) {
-		wrapped = internal;
-	}
-
-	@Override
-	protected CommandResult<K, V> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		CommandResult<K, V> res = wrapped.denote(operator, ctx);
-		if (res.status != Status.SUCCESS) return res;
-		return CommandResult.success(res.success().getChild(0));
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/GroupingCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/GroupingCommand.java
deleted file mode 100644
index 44aa2c1..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/GroupingCommand.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.blocks.ParseBlock;
-import bjc.pratt.commands.AbstractInitialCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A grouping operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class GroupingCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
-	private final ParseBlock<K, V, C> innerBlock;
-
-	private final Token<K, V> mark;
-
-	/**
-	 * Create a new grouping command.
-	 *
-	 * @param inner
-	 *        The inner block.
-	 *
-	 * @param marker
-	 *        The token to use as the node in the AST.
-	 */
-	public GroupingCommand(final ParseBlock<K, V, C> inner, final Token<K, V> marker) {
-		innerBlock = inner;
-
-		mark = marker;
-	}
-
-	@Override
-	protected CommandResult<K, V> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		final CommandResult<K,V> resOpr = innerBlock.parse(ctx);
-		Tree<Token<K, V>> opr = resOpr.success();
-		return CommandResult.success(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
deleted file mode 100644
index 6af6954..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java
+++ /dev/null
@@ -1,241 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import static bjc.pratt.blocks.ParseBlocks.repeating;
-import static bjc.pratt.blocks.ParseBlocks.simple;
-import static bjc.pratt.blocks.ParseBlocks.trigger;
-
-import java.util.function.UnaryOperator;
-
-import bjc.pratt.blocks.ParseBlock;
-import bjc.pratt.commands.*;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.functypes.MapBuilder;
-
-/**
- * * Contains factory methods for producing common implementations of
- * {@link InitialCommand}
- *
- * @author EVE
- *
- */
-public class InitialCommands {
-	/**
-	 * Create a new unary operator.
-	 * 
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @return A command implementing that operator.
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> unary(final int precedence) {
-		return new UnaryCommand<>(precedence);
-	}
-
-	/**
-	 * Create a new grouping operator.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the expression in the operator.
-	 *
-	 * @param term
-	 *        The type that closes the group.
-	 *
-	 * @param mark
-	 *        The token for the AST node of the group.
-	 *
-	 * @return A command implementing the operator.
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> grouping(final int precedence, final K term,
-			final Token<K, V> mark) {
-		final ParseBlock<K, V, C> innerBlock = simple(precedence, term, null);
-
-		return new GroupingCommand<>(innerBlock, mark);
-	}
-
-	/**
-	 * Create a new leaf operator.
-	 * 
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @return A command implementing the operator.
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> leaf() {
-		return new LeafCommand<>();
-	}
-
-	/**
-	 * Create a new pre-ternary operator, like an if-then-else statement.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param cond1
-	 *        The priority of the first block.
-	 *
-	 * @param block1
-	 *        The priority of the second block.
-	 *
-	 * @param block2
-	 *        The priority of the third block.
-	 *
-	 * @param mark1
-	 *        The marker that ends the first block.
-	 *
-	 * @param mark2
-	 *        The marker that ends the second block.
-	 *
-	 * @param term
-	 *        The token for the AST node of the group.
-	 *
-	 * @return A command implementing the operator.
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> preTernary(final int cond1, final int block1, final int block2,
-			final K mark1, final K mark2, final Token<K, V> term) {
-		final ParseBlock<K, V, C> condBlock = simple(cond1, mark1, null);
-		final ParseBlock<K, V, C> opblock1 = simple(block1, mark2, null);
-		final ParseBlock<K, V, C> opblock2 = simple(block2, null, null);
-
-		return new PreTernaryCommand<>(condBlock, opblock1, opblock2, term);
-	}
-
-	/**
-	 * Create a new named constant.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param val
-	 *        The value of the constant.
-	 *
-	 * @return A command implementing the constant.
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> constant(final Tree<Token<K, V>> val) {
-		return new ConstantCommand<>(val);
-	}
-
-	/**
-	 * Create a new delimited command. This is for block-like constructs.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param inner
-	 *        The precedence of the inner blocks.
-	 *
-	 * @param delim
-	 *        The marker between sub-blocks.
-	 *
-	 * @param mark
-	 *        The block terminator.
-	 *
-	 * @param term
-	 *        The token for the AST node of the group.
-	 *
-	 * @param onEnter
-	 *        The function to apply to the state on entering the block.
-	 *
-	 * @param onDelim
-	 *        The function to apply to the state on finishing a sub-block.
-	 *
-	 * @param onExit
-	 *        The function to apply to the state on exiting the block.
-	 *
-	 * @param statement
-	 *        Whether or not the sub-blocks are statements or expressions.
-	 *
-	 * @return A command implementing the operator.
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> delimited(final int inner, final K delim, final K mark,
-			final Token<K, V> term, final UnaryOperator<C> onEnter, final UnaryOperator<C> onDelim,
-			final UnaryOperator<C> onExit, final boolean statement) {
-		final ParseBlock<K, V, C> innerBlock = simple(inner, null, null);
-		final ParseBlock<K, V, C> delimsBlock = repeating(innerBlock, delim, mark, term, onDelim);
-		final ParseBlock<K, V, C> scopedBlock = trigger(delimsBlock, onEnter, onExit);
-
-		final GroupingCommand<K, V, C> command = new GroupingCommand<>(scopedBlock, term);
-
-		/*
-		 * Remove the wrapper layer from grouping-command on top of
-		 * RepeatingParseBlock.
-		 */
-		return denest(command);
-	}
-
-	/**
-	 * Create a new denesting command.
-	 *
-	 * This removes one tree-level, and is useful when combining complex
-	 * parse blocks with commands.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param comm
-	 *        The command to denest.
-	 *
-	 * @return A command that denests the result of the provided command.
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> denest(final InitialCommand<K, V, C> comm) {
-		return new DenestingCommand<>(comm);
-	}
-	
-	/**
-	 * Create a new 'panfix' command.
-	 * 
-	 * Form is <term> <expr> <term> <expr> <term>
-	 * 
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 * 
-	 * @param precedence The precedence for this operator
-	 * @param term The indicator for the operator
-	 * @param marker The token to mark this tree
-	 * 
-	 * @return A command that implements a panfix operator
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> panfix(final int precedence, final K term, final Token<K, V> marker) {
-		return new PanfixCommand<>(marker, term, precedence);
-	}
-
-	/**
-	 * Create a command that unconditionally returns a failure result.
-	 * 
-	 * @param <K> Token key type
-	 * @param <V> Token value type
-	 * @param <C> Context type
-	 * 
-	 * @return A command that unconditionally fails
-	 */
-	public static <K, V, C> InitialCommand<K, V, C> fail() {
-		return (operator, ctx) -> CommandResult.fail();
-	}
-	
-	/**
-	 * Create a new builder for branching/sub-command style commands.
-	 * 
-	 * @param <K> Token key type
-	 * @param <V> Value key type
-	 * @param <C> Context type
-	 * 
-	 * @return A builder for branching/sub-command style commands
-	 */
-	public static <K, V, C> MapBuilder<K, InitialCommand<K, V, C>, InitialCommand<K, V, C>> branch() {
-		return MapBuilder.from(BranchInitialCommand::new);
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/LeafCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/LeafCommand.java
deleted file mode 100644
index 20fb3d4..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/LeafCommand.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.InitialCommand;
-import bjc.pratt.tokens.Token;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A operator that stands for itself.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class LeafCommand<K, V, C> implements InitialCommand<K, V, C> {
-	@Override
-	public CommandResult<K, V> denote(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		return CommandResult.success(new SimpleTree<>(operator));
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/LeftBinaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/LeftBinaryCommand.java
deleted file mode 100644
index 9a72859..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/LeftBinaryCommand.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.commands.BinaryCommand;
-
-/**
- * A left-associative operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class LeftBinaryCommand<K, V, C> extends BinaryCommand<K, V, C> {
-	/**
-	 * Create a new left-associative operator.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 */
-	public LeftBinaryCommand(final int precedence) {
-		super(precedence);
-	}
-
-	@Override
-	protected int rightBinding() {
-		return 1 + leftBinding();
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/NonBinaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/NonBinaryCommand.java
deleted file mode 100644
index d303663..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/NonBinaryCommand.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.commands.BinaryCommand;
-
-/**
- * A non-associative operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class NonBinaryCommand<K, V, C> extends BinaryCommand<K, V, C> {
-	/**
-	 * Create a new non-associative operator.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 */
-	public NonBinaryCommand(final int precedence) {
-		super(precedence);
-	}
-
-	@Override
-	protected int rightBinding() {
-		return 1 + leftBinding();
-	}
-
-	@Override
-	public int nextBinding() {
-		return leftBinding() - 1;
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/NonInitialCommands.java b/JPratt/src/main/java/bjc/pratt/commands/impls/NonInitialCommands.java
deleted file mode 100644
index 6019ffe..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/NonInitialCommands.java
+++ /dev/null
@@ -1,167 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import java.util.Set;
-
-import bjc.pratt.blocks.ParseBlock;
-import bjc.pratt.blocks.SimpleParseBlock;
-import bjc.pratt.commands.NonInitialCommand;
-import bjc.pratt.tokens.Token;
-
-/**
- * Contains factory methods for producing common implementations of
- * {@link NonInitialCommand}
- *
- * @author EVE
- *
- */
-public class NonInitialCommands {
-	/**
-	 * Create a left-associative infix operator.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @return A command implementing that operator.
-	 */
-	public static <K, V, C> NonInitialCommand<K, V, C> infixLeft(final int precedence) {
-		return new LeftBinaryCommand<>(precedence);
-	}
-
-	/**
-	 * Create a right-associative infix operator.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @return A command implementing that operator.
-	 */
-	public static <K, V, C> NonInitialCommand<K, V, C> infixRight(final int precedence) {
-		return new RightBinaryCommand<>(precedence);
-	}
-
-	/**
-	 * Create a non-associative infix operator.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @return A command implementing that operator.
-	 */
-	public static <K, V, C> NonInitialCommand<K, V, C> infixNon(final int precedence) {
-		return new NonBinaryCommand<>(precedence);
-	}
-
-	/**
-	 * Create a chained operator.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @param chainSet
-	 *        The operators it forms a chain with.
-	 *
-	 * @param marker
-	 *        The token to use as the AST node for the chained operators.
-	 *
-	 * @return A command implementing that operator.
-	 */
-	public static <K, V, C> NonInitialCommand<K, V, C> chain(final int precedence, final Set<K> chainSet,
-			final Token<K, V> marker) {
-		return new ChainCommand<>(precedence, chainSet, marker);
-	}
-
-	/**
-	 * Create a postfix operator.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @return A command implementing that operator.
-	 */
-	public static <K, V, C> NonInitialCommand<K, V, C> postfix(final int precedence) {
-		return new PostfixCommand<>(precedence);
-	}
-
-	/**
-	 * Create a post-circumfix operator.
-	 *
-	 * This is an operator in form similar to array indexing.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of this operator
-	 *
-	 * @param insidePrecedence
-	 *        The precedence of the expression inside the operator
-	 *
-	 * @param closer
-	 *        The token that closes the circumfix.
-	 *
-	 * @param marker
-	 *        The token to use as the AST node for the operator.
-	 *
-	 * @return A command implementing that operator.
-	 */
-	public static <K, V, C> NonInitialCommand<K, V, C> postCircumfix(final int precedence,
-			final int insidePrecedence, final K closer, final Token<K, V> marker) {
-		final ParseBlock<K, V, C> innerBlock = new SimpleParseBlock<>(insidePrecedence, null, closer);
-
-		return new PostCircumfixCommand<>(precedence, innerBlock, marker);
-	}
-
-	/**
-	 * Create a ternary operator.
-	 *
-	 * This is like C's ?: operator.
-	 *
-	 * @param <K> The key type for the tokens. 
-	 * @param <V> The value type for the tokens.
-	 * @param <C> The context type for the tokens.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @param insidePrecedence
-	 *        The precedence of the inner section of the operator.
-	 *
-	 * @param closer
-	 *        The token that marks the end of the inner section.
-	 *
-	 * @param marker
-	 *        The token to use as the AST node for the operator.
-	 *
-	 * @param nonassoc
-	 *        True if the command is non-associative, false otherwise.
-	 *
-	 * @return A command implementing this operator.
-	 */
-	public static <K, V, C> NonInitialCommand<K, V, C> ternary(final int precedence, final int insidePrecedence,
-			final K closer, final Token<K, V> marker, final boolean nonassoc) {
-		final ParseBlock<K, V, C> innerBlock = new SimpleParseBlock<>(insidePrecedence, null, closer);
-
-		return new TernaryCommand<>(precedence, innerBlock, marker, nonassoc);
-	}
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/PanfixCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/PanfixCommand.java
deleted file mode 100644
index 04ad370..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/PanfixCommand.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.data.SimpleTree;
-import bjc.data.Tree;
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.InitialCommand;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * Represents a 'panfix' command, one where the operator is repeated prefix, infix and postfix.
- * @author bjcul
- *
- * @param <K> The key type of the token
- * @param <V> The value type of the token
- * @param <C> The context type of the parser
- */
-public final class PanfixCommand<K, V, C> implements InitialCommand<K, V, C> {
-	private final Token<K, V> marker;
-	private final K term;
-	private final int precedence;
-
-	/**
-	 * Create a new panfix command.
-	 * 
-	 * @param marker The marker token.
-	 * @param term The value to use as the root of the result-tree
-	 * @param precedence The precedence for this command
-	 */
-	public PanfixCommand(Token<K, V> marker, K term, int precedence) {
-		this.marker = marker;
-		this.term = term;
-		this.precedence = precedence;
-	}
-
-	@Override
-	public CommandResult<K, V> denote(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException {
-		CommandResult<K,V> resLeftSide = ctx.parse.parseExpression(precedence + 1, ctx.tokens, ctx.state, false);
-		if (resLeftSide.status != Status.SUCCESS) return resLeftSide;
-		Tree<Token<K, V>> leftSide = resLeftSide.success();
-		ctx.tokens.expect(term);
-		ctx.tokens.next();
-		
-		CommandResult<K, V> resRightSide = ctx.parse.parseExpression(precedence + 1, ctx.tokens, ctx.state, false);
-		if (resLeftSide.status != Status.SUCCESS) return resRightSide;
-		Tree<Token<K,V>> rightSide = resRightSide.success();
-		ctx.tokens.expect(term);
-		ctx.tokens.next();
-		
-		return CommandResult.success(new SimpleTree<>(marker, leftSide, rightSide));
-	}
-}
\ 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
deleted file mode 100644
index ec2c8fb..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/PostCircumfixCommand.java
+++ /dev/null
@@ -1,62 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.blocks.ParseBlock;
-import bjc.pratt.commands.BinaryPostCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A post-circumfix operator, like array indexing.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class PostCircumfixCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
-	private final ParseBlock<K, V, C> innerBlock;
-
-	private final Token<K, V> mark;
-
-	/**
-	 * Create a new post-circumfix operator.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 *
-	 * @param inner
-	 *        The block inside the expression.
-	 *
-	 * @param marker
-	 *        The token to use as the node for the AST.
-	 */
-	public PostCircumfixCommand(final int precedence, final ParseBlock<K, V, C> inner, final Token<K, V> marker) {
-		super(precedence);
-
-		if(inner == null) throw new NullPointerException("Inner block must not be null");
-
-		innerBlock = inner;
-
-		mark = marker;
-	}
-
-	@Override
-	public CommandResult<K, V> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
-			final ParserContext<K, V, C> ctx) throws ParserException {
-		final CommandResult<K,V> insideRes = innerBlock.parse(ctx);
-		if (insideRes.status != Status.SUCCESS) return insideRes;
-		Tree<Token<K, V>> inside = insideRes.success();
-		return CommandResult.success(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
deleted file mode 100644
index ff370d0..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/PostfixCommand.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.BinaryPostCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A postfix operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class PostfixCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
-	/**
-	 * Create a new postfix operator.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 */
-	public PostfixCommand(final int precedence) {
-		super(precedence);
-	}
-
-	@Override
-	public CommandResult<K, V> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
-			final ParserContext<K, V, C> ctx) throws ParserException {
-		return CommandResult.success(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
deleted file mode 100644
index 5d5cbe1..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/PreTernaryCommand.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.blocks.ParseBlock;
-import bjc.pratt.commands.AbstractInitialCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A prefix ternary operator, like an if/then/else group.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class PreTernaryCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
-	private final Token<K, V> trm;
-
-	private final ParseBlock<K, V, C> condBlock;
-
-	private final ParseBlock<K, V, C> opblock1;
-	private final ParseBlock<K, V, C> opblock2;
-
-	/**
-	 * Create a new ternary statement.
-	 *
-	 * @param cond
-	 *        The block for handling the condition.
-	 *
-	 * @param op1
-	 *        The block for handling the first operator.
-	 *
-	 * @param op2
-	 *        The block for handling the second operator.
-	 *
-	 * @param term
-	 *        The token to use as the node for the AST.
-	 */
-	public PreTernaryCommand(final ParseBlock<K, V, C> cond, final ParseBlock<K, V, C> op1,
-			final ParseBlock<K, V, C> op2, final Token<K, V> term) {
-		super();
-
-		if(cond == null)
-			throw new NullPointerException("Cond block must not be null");
-		else if(op1 == null)
-			throw new NullPointerException("Op block #1 must not be null");
-		else if(op2 == null) throw new NullPointerException("Op block #2 must not be null");
-
-		condBlock = cond;
-		opblock1 = op1;
-		opblock2 = op2;
-
-		trm = term;
-	}
-
-	@Override
-	protected CommandResult<K, V> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		final CommandResult<K,V> condRes = condBlock.parse(ctx);
-		if (condRes.status != Status.SUCCESS) return condRes;
-		Tree<Token<K, V>> cond = condRes.success();
-		
-		final CommandResult<K,V> op1Res = opblock1.parse(ctx);
-		if (op1Res.status != Status.SUCCESS) return op1Res;
-		Tree<Token<K, V>> op1 = op1Res.success();
-
-		final CommandResult<K,V> op2Res = opblock2.parse(ctx);
-		if (op2Res.status != Status.SUCCESS) return op2Res;
-		Tree<Token<K, V>> op2 = op2Res.success();
-		return CommandResult.success(new SimpleTree<>(trm, cond, op1, op2));
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/RightBinaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/RightBinaryCommand.java
deleted file mode 100644
index 4439930..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/RightBinaryCommand.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.commands.BinaryCommand;
-
-/**
- * A right-associative binary operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- * @param <V>
- *        The value type of the tokens.
- * @param <C>
- *        The state type of the parser.
- */
-public class RightBinaryCommand<K, V, C> extends BinaryCommand<K, V, C> {
-	/**
-	 * Create a new right-associative operator.
-	 *
-	 * @param precedence
-	 *        The precedence of the operator.
-	 */
-	public RightBinaryCommand(final int precedence) {
-		super(precedence);
-	}
-
-	@Override
-	protected int rightBinding() {
-		return leftBinding();
-	}
-}
\ 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
deleted file mode 100644
index 786dfec..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.blocks.ParseBlock;
-import bjc.pratt.commands.BinaryPostCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A ternary command, like C's ?:
- *
- * @author bjculkin
- *
- * @param <K> The key type of the tokens.
- *
- * @param <V> The value type of the tokens.
- *
- * @param <C> The state type of the parser.
- */
-public class TernaryCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
-	private final ParseBlock<K, V, C> innerBlck;
-
-	private final Token<K, V> mark;
-
-	private final boolean nonassoc;
-
-	/**
-	 * Create a new ternary command.
-	 *
-	 * @param precedence The precedence of this operator.
-	 *
-	 * @param innerBlock The representation of the inner block of the expression.
-	 *
-	 * @param marker     The token to use as the root of the AST node.
-	 *
-	 * @param isNonassoc Whether or not the conditional is associative.
-	 */
-	public TernaryCommand(final int precedence, final ParseBlock<K, V, C> innerBlock, final Token<K, V> marker,
-			final boolean isNonassoc) {
-		super(precedence);
-
-		if (innerBlock == null)
-			throw new NullPointerException("Inner block must not be null");
-		else if (marker == null)
-			throw new NullPointerException("Marker must not be null");
-
-		innerBlck = innerBlock;
-		mark = marker;
-		nonassoc = isNonassoc;
-	}
-
-	@Override
-	public CommandResult<K, V> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
-			final ParserContext<K, V, C> ctx) throws ParserException {
-		final CommandResult<K, V> innerRes = innerBlck.parse(ctx);
-		if (innerRes.status != Status.SUCCESS) return innerRes;
-		Tree<Token<K, V>> inner = innerRes.success();
-		
-		final CommandResult<K,V> outerRes = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state, false);
-		if (outerRes.status != Status.SUCCESS) return outerRes;
-		Tree<Token<K, V>> outer = outerRes.success();
-		return CommandResult.success(new SimpleTree<>(mark, inner, operand, outer));
-	}
-
-	@Override
-	public int nextBinding() {
-		if (nonassoc)
-			return leftBinding() - 1;
-
-		return leftBinding();
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/TransformingInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/TransformingInitialCommand.java
deleted file mode 100644
index 36f881d..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/TransformingInitialCommand.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import java.util.function.UnaryOperator;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.AbstractInitialCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.commands.InitialCommand;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * An initial command that transforms the result of another command.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class TransformingInitialCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
-	private final InitialCommand<K, V, C> internl;
-
-	private final UnaryOperator<Tree<Token<K, V>>> transfrm;
-
-	/**
-	 * Create a new transforming initial command.
-	 *
-	 * @param internal
-	 *        The initial command to delegate to.
-	 *
-	 * @param transform
-	 *        The transform to apply to the returned tree.
-	 */
-	public TransformingInitialCommand(final InitialCommand<K, V, C> internal,
-			final UnaryOperator<Tree<Token<K, V>>> transform) {
-		super();
-		internl = internal;
-		transfrm = transform;
-	}
-
-	@Override
-	protected CommandResult<K, V> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		CommandResult<K,V> result = internl.denote(operator, ctx);
-		if (result.status != Status.SUCCESS) return result;
-		
-		return CommandResult.success(transfrm.apply(result.success()));
-	}
-
-}
diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/UnaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/UnaryCommand.java
deleted file mode 100644
index 657c004..0000000
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/UnaryCommand.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package bjc.pratt.commands.impls;
-
-import bjc.pratt.ParserContext;
-import bjc.pratt.commands.AbstractInitialCommand;
-import bjc.pratt.commands.CommandResult;
-import bjc.pratt.commands.CommandResult.Status;
-import bjc.pratt.tokens.Token;
-import bjc.data.Tree;
-import bjc.data.SimpleTree;
-import bjc.utils.parserutils.ParserException;
-
-/**
- * A unary operator.
- *
- * @author bjculkin
- *
- * @param <K>
- *        The key type of the tokens.
- *
- * @param <V>
- *        The value type of the tokens.
- *
- * @param <C>
- *        The state type of the parser.
- */
-public class UnaryCommand<K, V, C> extends AbstractInitialCommand<K, V, C> {
-	private final int nullPwer;
-
-	/**
-	 * Create a new unary command.
-	 *
-	 * @param precedence
-	 *        The precedence of this operator.
-	 */
-	public UnaryCommand(final int precedence) {
-		if(precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative");
-
-		nullPwer = precedence;
-	}
-
-	@Override
-	protected CommandResult<K, V> intNullDenotation(final Token<K, V> operator, final ParserContext<K, V, C> ctx)
-			throws ParserException {
-		CommandResult<K,V> result = ctx.parse.parseExpression(nullPwer, ctx.tokens, ctx.state, false);
-		if (result.status != Status.SUCCESS) return result;
-		final Tree<Token<K, V>> opr = result.success();
-
-		return CommandResult.success(new SimpleTree<>(operator, opr));
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/parsing/package-info.java b/JPratt/src/main/java/bjc/pratt/parsing/package-info.java
deleted file mode 100644
index e7f4fa8..0000000
--- a/JPratt/src/main/java/bjc/pratt/parsing/package-info.java
+++ /dev/null
@@ -1 +0,0 @@
-package bjc.pratt.parsing;
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/tokens/ExpectionNotMet.java b/JPratt/src/main/java/bjc/pratt/tokens/ExpectionNotMet.java
deleted file mode 100644
index 2bd45e2..0000000
--- a/JPratt/src/main/java/bjc/pratt/tokens/ExpectionNotMet.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package bjc.pratt.tokens;
-
-import bjc.utils.parserutils.ParserException;
-
-/**
- * The exception thrown when an expectation fails.
- *
- * @author EVE
- *
- */
-public class ExpectionNotMet extends ParserException {
-	private static final long serialVersionUID = 4299299480127680805L;
-
-	/**
-	 * Create a new exception with the specified message.
-	 *
-	 * @param msg
-	 *        The message of the exception.
-	 */
-	public ExpectionNotMet(final String msg) {
-		super(msg);
-	}
-}
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/tokens/SimpleToken.java b/JPratt/src/main/java/bjc/pratt/tokens/SimpleToken.java
deleted file mode 100644
index 18e2e5a..0000000
--- a/JPratt/src/main/java/bjc/pratt/tokens/SimpleToken.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package bjc.pratt.tokens;
-
-import java.util.Objects;
-
-/**
- * Simple token implementation
- * 
- * @author bjcul
- * 
- * @param <K> The key type
- * @param <V> The value type
- *
- */
-public class SimpleToken<K, V> implements Token<K, V> {
-	private K key;
-	private V value;
-	
-	/**
-	 * Create a new token
-	 * @param key The key
-	 * @param value The value
-	 */
-	public SimpleToken(K key, V value) {
-		super();
-		this.key = key;
-		this.value = value;
-	}
-
-	@Override
-	public K getKey() {
-		return key;
-	}
-
-	@Override
-	public V getValue() {
-		return value;
-	}
-
-	@Override
-	public int hashCode() {
-		return Objects.hash(key, value);
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (getClass() != obj.getClass())
-			return false;
-		SimpleToken<?, ?> other = (SimpleToken<?, ?>) obj;
-		return Objects.equals(key, other.key) && Objects.equals(value, other.value);
-	}
-
-	@Override
-	public String toString() {
-		return "SimpleToken [key=" + key + ", value=" + value + "]";
-	}
-}
diff --git a/JPratt/src/main/java/bjc/pratt/tokens/SimpleTokenStream.java b/JPratt/src/main/java/bjc/pratt/tokens/SimpleTokenStream.java
deleted file mode 100644
index fba38bb..0000000
--- a/JPratt/src/main/java/bjc/pratt/tokens/SimpleTokenStream.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package bjc.pratt.tokens;
-
-import java.util.Iterator;
-
-import bjc.data.MarkListIterator;
-
-/**
- * Simple token stream implementation
- * @author bjcul
- *
- * @param <K> The key type
- * @param <V> The value type
- */
-public class SimpleTokenStream<K, V> extends TokenStream<K, V> {
-	private final MarkListIterator<Token<K, V>> iter;
-
-	private Token<K, V> curr;
-
-	private Token<K, V> terminal;
-	/**
-	 * Create a new token stream from a iterator.
-	 *
-	 * @param itr The iterator to use.
-	 * @param terminal The terminal token to use for end-of-stream
-	 *
-	 */
-	public SimpleTokenStream(final Iterator<Token<K, V>> itr, Token<K, V> terminal) {
-		this.iter = new MarkListIterator<>(itr);
-		this.terminal = terminal;
-	}
-
-	@Override
-	public Token<K, V> current() {
-		// Prime stream if necessary
-		if (curr == null)
-			return next();
-		return curr;
-	}
-
-	@Override
-	public Token<K, V> next() {
-		if (iter.hasNext()) {
-			curr = iter.next();
-		} else {
-			curr = terminal;
-		}
-
-		return curr;
-	}
-
-	@Override
-	public boolean hasNext() {
-		return iter.hasNext();
-	}
-
-	@Override
-	public void mark() {
-		iter.mark();
-	}
-
-	@Override
-	public void commit() {
-		iter.commit();
-
-		if (!iter.hasMark()) {
-			// No marks outstanding; we can release the previous state
-			iter.reset();
-		}
-	}
-
-	@Override
-	public void rollback() {
-		iter.rollback();
-
-		curr = iter.current();
-	}
-
-	@Override
-	public boolean hasMark() {
-		return iter.hasMark();
-	}
-}
diff --git a/JPratt/src/main/java/bjc/pratt/tokens/StringToken.java b/JPratt/src/main/java/bjc/pratt/tokens/StringToken.java
deleted file mode 100644
index 750518a..0000000
--- a/JPratt/src/main/java/bjc/pratt/tokens/StringToken.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package bjc.pratt.tokens;
-
-/**
- * Simple token implementation for strings.
- *
- * @author EVE
- *
- */
-public class StringToken implements Token<String, String> {
-	private final String key;
-	private final String val;
-
-	/**
-	 * Create a new string token.
-	 *
-	 * @param ky
-	 *        The key for the token.
-	 *
-	 * @param vl
-	 *        The value for the token.
-	 */
-	public StringToken(final String ky, final String vl) {
-		key = ky;
-		val = vl;
-	}
-
-	@Override
-	public String getKey() {
-		return key;
-	}
-
-	@Override
-	public String getValue() {
-		return val;
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-
-		int result = 1;
-		result = prime * result + (key == null ? 0 : key.hashCode());
-		result = prime * result + (val == null ? 0 : val.hashCode());
-
-		return result;
-	}
-
-	@Override
-	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof StringToken)) return false;
-
-		final StringToken other = (StringToken) obj;
-
-		if(key == null) {
-			if(other.key != null) return false;
-		} else if(!key.equals(other.key)) return false;
-
-		if(val == null) {
-			if(other.val != null) return false;
-		} else if(!val.equals(other.val)) return false;
-
-		return true;
-	}
-
-	@Override
-	public String toString() {
-		return String.format("StringToken [key='%s', val='%s']", key, val);
-	}
-
-	/**
-	 * Create a new literal token (has same key/value).
-	 *
-	 * @param val
-	 *        The value for the literal token.
-	 *
-	 * @return A literal token with that key.
-	 */
-	public static StringToken litToken(final String val) {
-		return new StringToken(val, val);
-	}
-}
diff --git a/JPratt/src/main/java/bjc/pratt/tokens/StringTokenStream.java b/JPratt/src/main/java/bjc/pratt/tokens/StringTokenStream.java
deleted file mode 100644
index 70876f2..0000000
--- a/JPratt/src/main/java/bjc/pratt/tokens/StringTokenStream.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package bjc.pratt.tokens;
-
-import static bjc.pratt.tokens.StringToken.litToken;
-
-import java.util.Iterator;
-
-import bjc.data.MarkListIterator;
-
-/**
- * Simple implementation of token stream for strings.
- *
- * The terminal token here is represented by a token with type and value
- * '(end)'.
- *
- * @author EVE
- *
- */
-public class StringTokenStream extends TokenStream<String, String> {
-	private final MarkListIterator<Token<String, String>> iter;
-	
-	private Token<String, String> curr;
-
-	/**
-	 * Create a new token stream from a iterator.
-	 *
-	 * @param itr
-	 *        The iterator to use.
-	 *
-	 */
-	public StringTokenStream(final Iterator<Token<String, String>> itr) {
-		iter = new MarkListIterator<>(itr);
-	}
-
-	@Override
-	public Token<String, String> current() {
-		// Prime stream if necessary
-		if (curr == null)
-			return next();
-		return curr;
-	}
-
-	@Override
-	public Token<String, String> next() {
-		if(iter.hasNext()) {
-			curr = iter.next();
-		} else {
-			curr = litToken("(end)");
-		}
-
-		return curr;
-	}
-
-	@Override
-	public boolean hasNext() {
-		return iter.hasNext();
-	}
-	
-	@Override
-	public void mark() {
-		iter.mark();
-	}
-	
-	@Override
-	public void commit() {
-		iter.commit();
-		
-		if (!iter.hasMark()) {
-			// No marks outstanding; we can release the previous state
-			iter.reset();
-		}
-	}
-	
-	@Override
-	public void rollback() {
-		iter.rollback();
-		
-		curr = iter.current();
-	}
-	
-	@Override
-	public boolean hasMark() {
- 		return iter.hasMark();
-	}
-}
diff --git a/JPratt/src/main/java/bjc/pratt/tokens/Token.java b/JPratt/src/main/java/bjc/pratt/tokens/Token.java
deleted file mode 100644
index 7de4ada..0000000
--- a/JPratt/src/main/java/bjc/pratt/tokens/Token.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package bjc.pratt.tokens;
-
-/**
- * Represents a simple parsing token.
- *
- * @author EVE
- *
- * @param <K>
- *        The key type of this token. Represents the type of the token.
- *
- * @param <V>
- *        The value type of this token. Represents any additional data for the
- *        token.
- *
- */
-public interface Token<K, V> {
-	/**
-	 * Get the key for this token.
-	 *
-	 * @return The key for this token
-	 */
-	K getKey();
-
-	/**
-	 * Get the value for this token.
-	 *
-	 * @return The value for this token.
-	 */
-	V getValue();
-}
diff --git a/JPratt/src/main/java/bjc/pratt/tokens/TokenStream.java b/JPratt/src/main/java/bjc/pratt/tokens/TokenStream.java
deleted file mode 100644
index dc09bcc..0000000
--- a/JPratt/src/main/java/bjc/pratt/tokens/TokenStream.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package bjc.pratt.tokens;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-import bjc.utils.funcutils.StringUtils;
-
-/**
- * A stream of tokens.
- *
- * @author EVE
- *
- * @param <K>
- *        The key type of the token.
- *
- * @param <V>
- *        The value type of the token.
- */
-public abstract class TokenStream<K, V> implements Iterator<Token<K, V>> {
-	/**
-	 * Get the current token.
-	 *
-	 * @return The current token.
-	 */
-	public abstract Token<K, V> current();
-
-	@Override
-	public abstract Token<K, V> next();
-
-	@Override
-	public abstract boolean hasNext();
-
-	/**
-	 * Place a mark in the current stream, which can be either returned to or abandoned later on.
-	 */
-	public abstract void mark();
-	
-	/**
-	 * Reset the stream to the state it was in when the last mark was taken.
-	 */
-	public abstract void rollback();
-	
-	/**
-	 * Check if the stream has at least one mark.
-	 * 
-	 * @return Whether or not at least one mark exists.
-	 */
-	public abstract boolean hasMark();
-	
-	/**
-	 * Remove the last mark placed into the stream. This prevents returning to it later on.
-	 */
-	public abstract void commit();
-	
-	/**
-	 * Utility method for checking that the next token is one of a specific
-	 * set of types, and then consuming it.
-	 *
-	 * @param expectedKeys
-	 *        The expected values
-	 *
-	 * @throws ExpectionNotMet
-	 *         If the token is not one of the expected types.
-	 */
-	public void expect(final Set<K> expectedKeys) throws ExpectionNotMet {
-		final K curKey = current().getKey();
-
-		if(!expectedKeys.contains(curKey)) {
-			final String expectedList = StringUtils.toEnglishList(expectedKeys.toArray(), false);
-
-			throw new ExpectionNotMet("One of '" + expectedList + "' was expected, not " + curKey);
-		}
-
-		next();
-	}
-
-	/**
-	 * Utility method for checking that the next token is one of a specific
-	 * set of types, and then consuming it.
-	 *
-	 * @param expectedKeys
-	 *        The expected values
-	 *
-	 * @throws ExpectionNotMet
-	 *         If the token is not one of the expected types.
-	 */
-	@SafeVarargs
-	public final void expect(final K... expectedKeys) throws ExpectionNotMet {
-		HashSet<K> keys = new HashSet<>(Arrays.asList(expectedKeys));
-		expect(keys);
-	}
-
-	/**
-	 * Check whether the head token is a certain type.
-	 *
-	 * @param val
-	 *        The type to check for.
-	 *
-	 * @return Whether or not the head token is of that type.
-	 */
-	public boolean headIs(final K val) {
-		return current().getKey().equals(val);
-	}
-}