7 files changed, 311 insertions, 148 deletions

diff --git a/base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java b/base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java
index 9c539e9..a526408 100644
--- a/base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java
+++ b/base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java
@@ -6,6 +6,7 @@ import java.util.Scanner;
 
 import bjc.esodata.AbbrevMap2;
 import bjc.utils.funcutils.StringUtils;
+import bjc.utils.parserutils.*;
 
 /**
  * Test for abbreviation map.
@@ -29,7 +30,7 @@ public class AbbrevMapTest {
 		String ln = scn.nextLine().trim();
 
 		while (!ln.equals("")) {
-			final List<String> commParts = StringUtils.processArguments(ln);
+			final List<String> commParts = TokenUtils.processArguments(ln);
 
 			switch (commParts.get(0)) {
 			case "add":
diff --git a/base/src/examples/java/bjc/utils/examples/BinarySearchTest.java b/base/src/examples/java/bjc/utils/examples/BinarySearchTest.java
deleted file mode 100644
index 5e8e372..0000000
--- a/base/src/examples/java/bjc/utils/examples/BinarySearchTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package bjc.utils.examples;
-
-import java.util.Scanner;
-
-import bjc.funcdata.bst.BinarySearchTree;
-import bjc.funcdata.bst.TreeLinearizationMethod;
-
-/**
- * Example showing how to use the binary search tree.
- *
- * @author ben
- *
- */
-public class BinarySearchTest {
-	private static void display(final BinarySearchTree<Character> tree,
-			final Scanner input) {
-		System.out.print(
-				"What order would you like the tree to be printed in (m for options): ");
-		char command;
-
-		while (true) {
-			command = input.nextLine().charAt(0);
-			TreeLinearizationMethod method = null;
-
-			switch (command) {
-			case 'm':
-				System.out.println("Possible tree printing methods: ");
-				System.out.println(
-						"\tp: Preorder printing (print parent first, then left & right).");
-				System.out.println(
-						"\ti: Inorder printing (print left first, then parent & right).");
-				System.out.println(
-						"\to: Postorder printing (print left first, then right & parent).");
-				break;
-			case 'p':
-				method = TreeLinearizationMethod.PREORDER;
-				break;
-			case 'i':
-				method = TreeLinearizationMethod.INORDER;
-				break;
-			case 'o':
-				method = TreeLinearizationMethod.POSTORDER;
-				break;
-			default:
-				System.out.println("ERROR: Unknown command.");
-			}
-
-			if (method != null) {
-				tree.traverse(method, element -> {
-					System.out.println("Node: " + element);
-					return true;
-				});
-
-				return;
-			}
-
-			System.out.print(
-					"What order would you like the tree to be printed in (m for options): ");
-		}
-	}
-
-	/**
-	 * Main method of class
-	 *
-	 * @param args
-	 *             Unused CLI args
-	 */
-	public static void main(final String[] args) {
-		final Scanner input = new Scanner(System.in);
-		System.out.println("Binary Tree Constructor/Searcher");
-		final BinarySearchTree<Character> tree
-				= new BinarySearchTree<>((o1, o2) -> o1 - o2);
-
-		char command = ' ';
-		while (command != 'e') {
-			System.out.print("Enter a command (m for help): ");
-			command = input.nextLine().charAt(0);
-
-			switch (command) {
-			case 'm':
-				System.out.println("Valid commands: ");
-				System.out.println("\tm: Display this help message.");
-				System.out.println("\te: Exit this program.");
-				System.out.println("\ta: Add a node to the binary tree.");
-				System.out.println("\td: Display the binary tree.");
-				System.out.println("\tr: Remove a node from the binary tree.");
-				System.out.println("\tf: Check if a given node is in the binary tree.");
-				System.out.println("\tt: Trim all deleted nodes from the tree.");
-				System.out.println("\tb: Balance the tree (also trims dead nodes)");
-				break;
-			case 'a':
-				System.out.print("Enter the letter to add to the binary tree: ");
-				command = input.nextLine().charAt(0);
-
-				tree.addNode(command);
-				break;
-			case 'r':
-				System.out.print("Enter the letter to add to the binary tree: ");
-				command = input.nextLine().charAt(0);
-
-				tree.deleteNode(command);
-				break;
-			case 'd':
-				display(tree, input);
-				break;
-			case 'f':
-				System.out.print("Enter the letter to add to the binary tree: ");
-				command = input.nextLine().charAt(0);
-
-				final boolean inTree = tree.isInTree(command);
-				if (inTree) {
-					System.out.printf("Node %s was found\n", command);
-				} else {
-					System.out.printf("Node %s was not found\n", command);
-				}
-				break;
-			case 't':
-				tree.trim();
-				break;
-			case 'b':
-				tree.balance();
-				break;
-			default:
-				System.out.println("ERROR: Unrecognized command.");
-			}
-		}
-
-		input.close();
-	}
-}
diff --git a/base/src/examples/java/bjc/utils/examples/FunctionalFizzBuzz.java b/base/src/examples/java/bjc/utils/examples/FunctionalFizzBuzz.java
new file mode 100644
index 0000000..08551c7
--- /dev/null
+++ b/base/src/examples/java/bjc/utils/examples/FunctionalFizzBuzz.java
@@ -0,0 +1,71 @@
+package bjc.utils.examples;
+
+import java.util.function.*;
+import bjc.data.*;
+
+import static bjc.functypes.Combinators.*;
+
+/**
+ * @author Ben Culkin
+ *
+ */
+public class FunctionalFizzBuzz {	
+	interface FizzBuzzFunc 
+		extends Function<UnaryOperator<String>, UnaryOperator<String>> {
+		// Alias type
+	}
+	
+	/**
+	 * Calculate fizz-buzz in an un-functional functional way.
+	 * 
+	 * @param args Ignored CLI args
+	 */
+	public static void main(String[] args) {
+		// Do something, at some point
+		times(
+				100,
+				andThen(
+  				invoke(
+      			introducing(
+      					() -> new IntHolder(),
+      					(holder, arg) -> {			
+      							Consumer<Integer>   numSetter2 = (num) -> holder.set(num);        		
+      							
+      							return (num) -> beforeThis(
+      									numSetter2,
+      									compose(
+      											input  -> Integer.toString(input),
+      											strang -> 
+      													fbMaker(3, "Fizz", "", holder)
+      														.apply(
+      															fbMaker(5, "Buzz", "", holder)
+      																.apply(ignore -> ignore)
+      														)
+      														.apply(strang)
+      									)
+      							).apply(num);
+      					}
+      			)
+      		),
+  				System.out::println
+  			)
+		);
+	}
+	
+	private static FizzBuzzFunc fbMaker(
+			int cond, String initial, String interleave, IntHolder var) {
+		return func -> invoke(
+				iftt(
+						ignored1 -> var.get() % cond == 0,
+						arg      -> initial + func.apply(interleave),
+						func
+				)
+		);
+	}
+	
+	private static <Input, Output> Function<Input, Output> iftt(Predicate<Input> in,
+			Output ifTrue,
+			Output ifFalse) {
+		return (arg) -> in.test(arg) ? ifTrue : ifFalse;
+	}
+}
\ No newline at end of file
diff --git a/base/src/examples/java/bjc/utils/examples/ShuntTest.java b/base/src/examples/java/bjc/utils/examples/ShuntTest.java
index b62a5a6..39d37ee 100644
--- a/base/src/examples/java/bjc/utils/examples/ShuntTest.java
+++ b/base/src/examples/java/bjc/utils/examples/ShuntTest.java
@@ -3,7 +3,7 @@ package bjc.utils.examples;
 import java.util.Scanner;
 
 import bjc.funcdata.FunctionalStringTokenizer;
-import bjc.funcdata.IList;
+import bjc.funcdata.ListEx;
 import bjc.utils.parserutils.ShuntingYard;
 
 /**
@@ -12,7 +12,8 @@ import bjc.utils.parserutils.ShuntingYard;
  * @author ben
  *
  */
-public class ShuntTest {
+public class ShuntTest
+{
 	/**
 	 * Main method
 	 *
@@ -20,16 +21,16 @@ public class ShuntTest {
 	 *             Unused CLI args
 	 */
 	public static void main(final String[] args) {
-		final Scanner inputSource = new Scanner(System.in);
+		Scanner inputSource = new Scanner(System.in);
 
 		System.out.print("Enter a expression to shunt: ");
-		final String line = inputSource.nextLine();
+		String line = inputSource.nextLine();
 
-		final ShuntingYard<String> yard = new ShuntingYard<>(true);
+		ShuntingYard<String> yard = new ShuntingYard<>(true);
 
-		final IList<String> preTokens
-				= new FunctionalStringTokenizer(line).toList(strang -> strang);
-		final IList<String> shuntedTokens = yard.postfix(preTokens, strang -> strang);
+		FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer(line);
+		ListEx<String> preTokens = tokenizer.toList(strang -> strang);
+		ListEx<String> shuntedTokens = yard.postfix(preTokens, strang -> strang);
 
 		System.out.println(shuntedTokens.toString());
 
diff --git a/base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java b/base/src/examples/java/bjc/utils/examples/gen/DiabloItemGen.java
index 935a189..8699527 100644
--- a/base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java
+++ b/base/src/examples/java/bjc/utils/examples/gen/DiabloItemGen.java
@@ -1,7 +1,7 @@
-package bjc.utils.examples.rangen;
+package bjc.utils.examples.gen;
 
 import bjc.funcdata.FunctionalStringTokenizer;
-import bjc.funcdata.IList;
+import bjc.funcdata.ListEx;
 import bjc.utils.gen.WeightedGrammar;
 
 /**
@@ -15,7 +15,7 @@ public class DiabloItemGen {
 
 	private static void addCase(final String ruleName, final int probability,
 			final String ruleParts) {
-		final IList<String> parts = FunctionalStringTokenizer.fromString(ruleParts)
+		final ListEx<String> parts = FunctionalStringTokenizer.fromString(ruleParts)
 				.toList(strang -> strang);
 
 		rules.addCase(ruleName, probability, parts);
@@ -85,7 +85,7 @@ public class DiabloItemGen {
 		addInfixRules();
 
 		for (int i = 0; i < 100; i++) {
-			final IList<String> ls = rules.generateListValues("<item>", " ");
+			final ListEx<String> ls = rules.generateListValues("<item>", " ");
 
 			final StringBuilder sb = new StringBuilder();
 			ls.forEach(sb::append);
diff --git a/base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java b/base/src/examples/java/bjc/utils/examples/gen/RandomStringExamples.java
index bdc4f53..5e71ce0 100644
--- a/base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java
+++ b/base/src/examples/java/bjc/utils/examples/gen/RandomStringExamples.java
@@ -1,8 +1,8 @@
-package bjc.utils.examples.rangen;
+package bjc.utils.examples.gen;
 
 import bjc.funcdata.FunctionalList;
 import bjc.funcdata.FunctionalStringTokenizer;
-import bjc.funcdata.IList;
+import bjc.funcdata.ListEx;
 import bjc.utils.gen.RandomGrammar;
 
 /**
@@ -15,10 +15,10 @@ public class RandomStringExamples {
 	private static RandomGrammar<String> rg;
 
 	private static void addRule(final String rule, final String... cases) {
-		final IList<IList<String>> cses = new FunctionalList<>();
+		final ListEx<ListEx<String>> cses = new FunctionalList<>();
 
 		for (final String strang : cases) {
-			final IList<String> lst
+			final ListEx<String> lst
 					= FunctionalStringTokenizer.fromString(strang).toList(s -> s);
 
 			cses.add(lst);
@@ -56,7 +56,7 @@ public class RandomStringExamples {
 		addRule("<something>", "<activity>", "<activity> with <person>", "<object>");
 
 		for (int i = 0; i < 10; i++) {
-			final IList<String> ls = rg.generateListValues("<sentance>", " ");
+			final ListEx<String> ls = rg.generateListValues("<sentance>", " ");
 
 			final StringBuilder sb = new StringBuilder();
 			ls.forEach(sb::append);
diff --git a/base/src/examples/java/bjc/utils/examples/gen/ZadronsPouch.java b/base/src/examples/java/bjc/utils/examples/gen/ZadronsPouch.java
new file mode 100644
index 0000000..184d127
--- /dev/null
+++ b/base/src/examples/java/bjc/utils/examples/gen/ZadronsPouch.java
@@ -0,0 +1,220 @@
+package bjc.utils.examples.gen;
+
+import bjc.funcdata.FunctionalList;
+import bjc.funcdata.FunctionalStringTokenizer;
+import bjc.funcdata.ListEx;
+import bjc.utils.gen.RandomGrammar;
+
+/**
+ * Example showing code manipulate of random grammars
+ *
+ * @author ben
+ */
+public class ZadronsPouch {
+	/**
+	 * Main method for running application
+	 *
+	 * @param args
+	 * 	Unused CLI args
+	 */
+	public static void main(String[] args) {
+		ZadronsPouch zp = new ZadronsPouch();
+
+		for (int i = 0; i < 100; i++) {
+			ListEx<String> ls = zp.grammar.generateListValues("[item]", " ");
+
+			StringBuilder sb = new StringBuilder();
+
+			ls.forEach(sp -> sb.append(sp));
+
+			System.out.println(sb.toString().replaceAll("\\s+", " "));
+		}
+	}
+
+	private RandomGrammar<String> grammar;
+
+	/** Create a new instance with a grammar */
+	public ZadronsPouch() {
+		grammar = new RandomGrammar<>();
+
+		/*
+		 * @NOTE
+		 * 	Should there be some sort of builder sort of interface?
+		 */
+		addRule("[item]",
+		        "[egg]",      "[glove]", "[crys-sphere]", "[rock]",
+		        "[figurine]", "[vial]",  "[mini-weapon]", "[bag]",
+		        "[card]",     "[rope]",  "[box]",         "[wand]");
+
+		addEggRules();
+		addGloveRules();
+		addCrysSphereRules();
+		addRockRules();
+
+		addFigurineRules();
+		addVialRules();
+		addMiniWeaponRules();
+		addBagRules();
+
+		addCardRules();
+		addRopeRules();
+		addBoxRules();
+		addWandRules();
+	}
+
+	private void addBagRules() {
+		addRule("[bag]",
+		        "bag of [bag-type]", "[sack-type] sack", "[purse-type] purse");
+		addRule("[bag-type]",
+		        "holding",   "tricks",     "useful items",
+		        "devouring", "dwarf-kind", "invisible cloth",
+		        "monster summoning");
+		addRule("[sack-type]",
+		        "lunch", "recursive");
+		addRule("[purse-type]",
+		        "everfull");
+	}
+
+	private void addBoxRules() {
+		addRule("[box]",
+		        "[box-type] box", "cube of [box-type]");
+		addRule("[box-type]",
+		        "limited-force",    "frost-resisting", "morphing",
+		        "self-destructing", "pandora",         "panicking");
+	}
+
+	private void addCardRules() {
+		addRule("[card]",
+		        "card of [card-type]", "[card-type] card");
+		addRule("[card-type]",
+		        "fate",        "teleporting", "elusive treasure", "spell-storing",
+		        "many-things", "imprisoning", "messaging",        "bounty");
+	}
+
+	private void addCrysSphereRules() {
+		addRule("[crys-sphere]",
+		        "[sphere-type] spheres",     "[sphere-type] sphere",
+		        "lens of [lens-type]",       "[crystal-type] crystal",
+		        "crystal of [crystal-type]", "crystal ball",
+		        "crystal ball of [crys-suffix]");
+		addRule("[sphere-type]",
+		        "microphonic", "seeing-eye");
+		addRule("[lens-type]",
+		        "detection");
+		addRule("[crystal-type]",
+		        "prison", "radar");
+		addRule("[crys-suffix]",
+		        "jumping");
+	}
+
+	private void addEggRules() {
+		addRule("[egg]",
+		        "[egg-type] egg");
+		addRule("[egg-type]",
+		        "copper", "stone",      "golden",
+		        "white",  "white/pink", "glass");
+	}
+
+	private void addFigurineRules() {
+		addRule("[figurine]",
+		        "[fig-material] [fig-animal]");
+		addRule("[fig-material]",
+		        "golden", "onyx",   "serpentine", "ivory",
+		        "marble", "bronze", "jade",       "limestone");
+		addRule("[fig-animal]",
+		        "lion",     "dog",     "owl",    "goat",
+		        "elephant", "warrior", "palace", "leprechaun");
+	}
+
+	private void addGloveRules() {
+		addRule("[glove]",
+		        "gauntlets of [gauntlet-type]",
+		        "gloves of [glove-type]",
+		        "[glove-type] gloves");
+		addRule("[gauntlet-type]",
+		        "dexterity", "power");
+		addRule("[glove-type]",
+		        "pushing", "choking", "bigby", "stunning");
+	}
+
+	private void addMiniWeaponRules() {
+		addRule("[mini-weapon]",
+		        "minature [weapon-type]", "small [weapon-type]",
+		        "tiny [weapon-type]",     "[sling-type] sling",
+		        "[weapon-type]");
+		addRule("[weapon-type]",
+		        "boomerang", "arrow",  "net",
+		        "catapult",  "hammer", "sword", "club");
+		addRule("[sling-type]",
+		        "seeking");
+	}
+
+	private void addRockRules() {
+		addRule("[rock]",
+		        "[pebble-type] pebble", "stone of [stone-type]",
+		        "[stone-type] stone",   "brick of [brick-type]",
+		        "[geode-type] geode");
+		addRule("[pebble-type]",
+		        "inscribed", "elemental control");
+		addRule("[stone-type]",
+		        "good-luck",     "weight",
+		        "blind-defense", "metal-clinging");
+		addRule("[brick-type]",
+		        "flying");
+		addRule("[geode-type]",
+		        "ioun");
+	}
+
+	private void addRopeRules() {
+		addRule("[rope]",
+		        "[rope-type] rope", "rope of [rope-type]",
+		        "ball of [string-type] [string-kind]");
+		addRule("[rope-type]",
+		        "trick",    "entangling", "climbing",   "dancing",
+		        "tripping", "snaring",    "levitating", "self-entangling");
+		addRule("[string-type]",
+		        "endless");
+		addRule("[string-kind]",
+		        "string", "yarn");
+	}
+
+	private void addRule(String rule, String... cases) {
+		ListEx<ListEx<String>> cses = new FunctionalList<>();
+
+		for (String strang : cases) {
+			cses.add(FunctionalStringTokenizer.fromString(strang).toList(s -> s));
+		}
+
+		grammar.makeRule(rule, cses);
+	}
+
+	private void addVialRules() {
+		addRule("[vial]",
+		        "vial of [vial-type]",  "[vial-type] vial",
+		        "[bottle-type] bottle", "[flask-type] flask");
+		addRule("[vial-type]",
+		        "holding",    "trapping",
+		        "experience", "unnatural regeneration");
+		addRule("[bottle-type]",
+		        "ever-smoking", "wheezing",
+		        "blank potion");
+		addRule("[flask-type]",
+		        "iron");
+	}
+
+	private void addWandRules() {
+		addRule("[wand]",
+		        "[wand-type] wand", "wand of [wand-type]",
+		        "canceling [wand-type] wand");
+		addRule("[wand-type]",
+		        "magic missile", "[spell-1]",      "[spell-2]",
+		        "gusting",       "life-detecting", "zadron");
+		addRule("[spell-1]",
+		        "frost",        "fire",         "lightning",   "fear",
+		        "illumination", "polymorphing", "conjuration", "paralyzing");
+		addRule("[spell-2]",
+		        "[spell2-type] detecting");
+		addRule("[spell2-type]",
+		        "magic", "enemy", "secret door/trap");
+	}
+}