1 files changed, 0 insertions, 216 deletions
diff --git a/src/main/java/bjc/funcdata/IMap.java b/src/main/java/bjc/funcdata/IMap.java
deleted file mode 100644
index ca9ef11..0000000
--- a/src/main/java/bjc/funcdata/IMap.java
+++ /dev/null
@@ -1,216 +0,0 @@
-package bjc.funcdata;
-
-import java.util.*;
-import java.util.function.*;
-
-/**
- * Functional wrapper over map providing some useful things.
- *
- * @author ben
- *
- * @param <KeyType>
- *                    The type of this map's keys.
- *
- * @param <ValueType>
- *                    The type of this map's values.
- */
-public interface IMap<KeyType, ValueType> extends IFreezable {
-	/**
-	 * Execute an action for each entry in the map.
-	 *
-	 * @param action
-	 *               The action to execute for each entry in the map.
-	 */
-	void forEach(BiConsumer<KeyType, ValueType> action);
-
-	/**
-	 * Perform an action for each key in the map.
-	 *
-	 * @param action
-	 *               The action to perform on each key in the map.
-	 */
-	default void forEachKey(final Consumer<KeyType> action) {
-		forEach((key, val) -> action.accept(key));
-	}
-
-	/**
-	 * Perform an action for each value in the map.
-	 *
-	 * @param action
-	 *               The action to perform on each value in the map.
-	 */
-	default void forEachValue(final Consumer<ValueType> action) {
-		forEach((key, val) -> action.accept(val));
-	}
-
-	/**
-	 * Check if this map contains the specified key.
-	 *
-	 * @param key
-	 *            The key to check.
-	 *
-	 * @return Whether or not the map contains the key.
-	 */
-	boolean containsKey(KeyType key);
-
-	/**
-	 * Get the value assigned to the given key.
-	 *
-	 * @param key
-	 *            The key to look for a value under.
-	 *
-	 * @return The value of the key.
-	 */
-	Optional<ValueType> get(KeyType key);
-
-	/**
-	 * Add an entry to the map.
-	 *
-	 * @param key
-	 *            The key to put the value under.
-	 *
-	 * @param val
-	 *            The value to add.
-	 *
-	 * @return The previous value of the key in the map, or null if the key wasn't
-	 *         in the map. However, note that it may also return null if the key was
-	 *         set to null.
-	 *
-	 * @throws UnsupportedOperationException
-	 *                                       If the map implementation doesn't
-	 *                                       support modifying the map.
-	 */
-	ValueType put(KeyType key, ValueType val);
-
-	/** Delete all the values in the map. */
-	default void clear() {
-		if (isFrozen()) throw new ObjectFrozen("Can't clear a frozen map");
-		
-		keyList().forEach(IMap.this::remove);
-	}
-
-	/**
-	 * Get the number of entries in this map.
-	 *
-	 * @return The number of entries in this map.
-	 */
-	default int size() {
-		return keyList().getSize();
-	}
-
-	/**
-	 * Remove the value bound to the key.
-	 *
-	 * @param key
-	 *            The key to remove from the map.
-	 *
-	 * @return The previous value for the key in the map, or null if the key wasn't
-	 *         in the class. NOTE: Just because you received null, doesn't mean the
-	 *         map wasn't changed. It may mean that someone put a null value for
-	 *         that key into the map.
-	 */
-	ValueType remove(KeyType key);
-
-	/**
-	 * Get a list of all the keys in this map.
-	 *
-	 * @return A list of all the keys in this map.
-	 */
-	IList<KeyType> keyList();
-
-	/**
-	 * Get a list of the values in this map.
-	 *
-	 * @return A list of values in this map.
-	 */
-	default IList<ValueType> valueList() {
-		final IList<ValueType> returns = new FunctionalList<>();
-
-		for (final KeyType key : keyList()) {
-			returns.add(get(key).orElse(null));
-		}
-
-		return returns;
-	}
-	
-	/*
-	 * @NOTE Do we want this to be the semantics for transform, or do we want to go
-	 * to semantics using something like Isomorphism, or doing a one-time bulk
-	 * conversion of the values?
-	 */
-	
-	/**
-	 * Transform the values returned by this map.
-	 *
-	 * NOTE: This transform is applied once for each lookup of a value, so the
-	 * transform passed should be a proper function, or things will likely not work
-	 * as expected.
-	 *
-	 * @param <V2>
-	 *                    The new type of returned values.
-	 *
-	 * @param transformer
-	 *                    The function to use to transform values.
-	 *
-	 * @return The map where each value will be transformed after lookup.
-	 */
-	default <V2> IMap<KeyType, V2> transform(final Function<ValueType, V2> transformer) {
-		return new TransformedValueMap<>(this, transformer);
-	}
-
-	/**
-	 * Extends this map, creating a new map that will delegate queries to the map,
-	 * but store any added values itself.
-	 *
-	 * @return An extended map.
-	 */
-	default IMap<KeyType, ValueType> extend() {
-	   return extend(new FunctionalMap<>());
-	};
-
-	
-	/**
-	 * Extend this map, creating a new map that will delegate queries to 
-	 * the current map but store any added values in the provided map.
-	 * 
-	 * @param backer The map to store values in.
-	 * 
-	 * @return An extended map, with the specified backing map.
-	 */
-	default IMap<KeyType, ValueType> extend(IMap<KeyType, ValueType> backer) {
-		return new ExtendedMap<>(this, backer);
-	};
-	
-	/**
-	 * Static method to create a basic instance of IMap.
-	 * 
-	 * @param <KeyType2> The key type of the map.
-	 * @param <ValueType2> The value type of the map.
-	 * 
-	 * @param args A series of key-value pairs. You will get an error if you don't
-	 *             provide the correct number of arguments (a number divisible by 2);
-	 *             however, if you pass arguments of the wrong type, you will not
-	 *             get a compile error, and usually won't get a runtime error in
-	 *             construction. However, you will get a ClassCastException as soon
-	 *             as you do something that attempts to iterate over the keys or values
-	 *             of the map.
-	 * 
-	 * @return A map, constructed from the provided values.
-	 * 
-	 * @throws IllegalArgumentException If you provide an incomplete pair of arguments.
-	 */
-	@SuppressWarnings("unchecked")
-	static <KeyType2, ValueType2> IMap<KeyType2, ValueType2> of(Object... args) {
-		if (args.length % 2 != 0) throw new IllegalArgumentException("Args must be in the form of key-value pairs");
-		
-		IMap<KeyType2, ValueType2> map = new FunctionalMap<>();
-		for (int index = 0; index < args.length; index += 2) {
-			KeyType2   key   = (KeyType2)   args[index];
-			ValueType2 value = (ValueType2) args[index + 1];
-			
-			map.put(key, value);
-		}
-		
-		return map;
-	}
-}