From 44be6e6cd7671dd243056107ffa6201504f7fbce Mon Sep 17 00:00:00 2001
From: Ben Culkin <scorpress@gmail.com>
Date: Sun, 25 Jun 2023 15:50:38 -0400
Subject: Update a number of things

---
 src/main/java/bjc/data/BooleanToggle.java          |  2 +-
 src/main/java/bjc/data/Either.java                 | 24 ++++++
 src/main/java/bjc/data/Lazy.java                   | 17 ++---
 src/main/java/bjc/data/OneWayToggle.java           |  3 +-
 src/main/java/bjc/data/Pair.java                   |  9 +++
 src/main/java/bjc/data/PetriNet.java               | 17 +++++
 src/main/java/bjc/data/PetriTransition.java        | 59 +++++++++++++-
 src/main/java/bjc/data/Triple.java                 | 78 +++++++++++++++++++
 src/main/java/bjc/data/ValueToggle.java            |  6 +-
 src/main/java/bjc/esodata/AbbrevMap2.java          | 71 +++++++++++++----
 .../java/bjc/esodata/ClosedSpoolException.java     | 48 ++++++++++++
 src/main/java/bjc/esodata/ComplexSpooler.java      | 43 +++++++++++
 src/main/java/bjc/esodata/DefaultList.java         |  3 +-
 src/main/java/bjc/esodata/DefaultSpool.java        | 80 +++++++++++++++++++
 src/main/java/bjc/esodata/DefaultSpooler.java      | 43 +++++++++++
 src/main/java/bjc/esodata/KeyedList.java           | 11 +++
 src/main/java/bjc/esodata/Multimap.java            |  5 ++
 src/main/java/bjc/esodata/NestList.java            |  6 +-
 src/main/java/bjc/esodata/PushdownMap.java         |  4 +-
 src/main/java/bjc/esodata/Spool.java               | 48 ++++++++++++
 src/main/java/bjc/esodata/Spooler.java             | 42 ++++++++++
 src/main/java/bjc/esodata/TSetMultimap.java        |  3 +-
 src/main/java/bjc/esodata/TapeLibrary.java         |  4 +-
 src/main/java/bjc/esodata/spool/Spool.java         | 22 ------
 src/main/java/bjc/esodata/spool/Spooler.java       | 22 ------
 src/main/java/bjc/funcdata/ExtendedMap.java        | 13 ++--
 src/main/java/bjc/funcdata/Freezable.java          |  1 +
 src/main/java/bjc/funcdata/FunctionalMap.java      |  8 +-
 src/main/java/bjc/funcdata/MapEx.java              |  2 +-
 .../java/bjc/funcdata/TransformedValueMap.java     |  4 +-
 src/main/java/bjc/functypes/Combinators.java       | 17 +++++
 src/main/java/bjc/functypes/Const.java             | 18 +++++
 src/main/java/bjc/functypes/Predicates.java        |  3 -
 src/main/java/bjc/functypes/ThrowFunction.java     | 24 +++---
 src/main/java/bjc/functypes/TriFunction.java       | 14 ++++
 src/main/java/bjc/functypes/VarArgFunction.java    | 22 ++++++
 src/main/java/bjc/optics/Adapter.java              | 15 ++++
 src/main/java/bjc/optics/AdapterX.java             | 89 ++++++++++++++++++++++
 src/main/java/bjc/optics/Adapters.java             | 47 ++++++++++++
 src/main/java/bjc/optics/Lens.java                 | 38 +++++++--
 src/main/java/bjc/optics/LensX.java                |  1 -
 src/main/java/bjc/optics/Lenses.java               | 23 +++++-
 src/main/java/bjc/optics/Prism.java                | 70 +++++++++++++++++
 src/main/java/bjc/optics/PrismX.java               | 67 ++++++++++++++++
 src/main/java/bjc/optics/Prisms.java               | 56 ++++++++++++++
 src/main/java/bjc/optics/Traversal.java            | 14 ++++
 src/main/java/bjc/optics/TraversalX.java           | 54 +++++++++++++
 src/main/java/bjc/typeclasses/Applicative.java     | 39 ++++++++++
 src/main/java/bjc/typeclasses/BiContainer.java     |  8 ++
 src/main/java/bjc/typeclasses/Container.java       |  7 ++
 src/main/java/bjc/typeclasses/FunList.java         | 47 ++++++++++++
 src/main/java/bjc/typeclasses/FunctorX.java        | 10 +++
 src/main/java/bjc/typeclasses/ListC.java           | 16 ++++
 src/main/java/bjc/typeclasses/PFLens.java          | 21 +++--
 src/main/java/module-info.java                     |  2 +
 55 files changed, 1292 insertions(+), 128 deletions(-)
 create mode 100644 src/main/java/bjc/data/Triple.java
 create mode 100644 src/main/java/bjc/esodata/ClosedSpoolException.java
 create mode 100644 src/main/java/bjc/esodata/ComplexSpooler.java
 create mode 100644 src/main/java/bjc/esodata/DefaultSpool.java
 create mode 100644 src/main/java/bjc/esodata/DefaultSpooler.java
 create mode 100644 src/main/java/bjc/esodata/Spool.java
 create mode 100644 src/main/java/bjc/esodata/Spooler.java
 delete mode 100644 src/main/java/bjc/esodata/spool/Spool.java
 delete mode 100644 src/main/java/bjc/esodata/spool/Spooler.java
 create mode 100644 src/main/java/bjc/functypes/VarArgFunction.java
 create mode 100644 src/main/java/bjc/optics/Adapter.java
 create mode 100644 src/main/java/bjc/optics/AdapterX.java
 create mode 100644 src/main/java/bjc/optics/Adapters.java
 create mode 100644 src/main/java/bjc/optics/Prism.java
 create mode 100644 src/main/java/bjc/optics/Prisms.java
 create mode 100644 src/main/java/bjc/optics/Traversal.java
 create mode 100644 src/main/java/bjc/optics/TraversalX.java
 create mode 100644 src/main/java/bjc/typeclasses/Applicative.java
 create mode 100644 src/main/java/bjc/typeclasses/FunctorX.java

diff --git a/src/main/java/bjc/data/BooleanToggle.java b/src/main/java/bjc/data/BooleanToggle.java
index 56cbdf0..41f2564 100644
--- a/src/main/java/bjc/data/BooleanToggle.java
+++ b/src/main/java/bjc/data/BooleanToggle.java
@@ -83,7 +83,7 @@ public class BooleanToggle implements Toggle<Boolean> {
 		final BooleanToggle other = (BooleanToggle) obj;
 
 		if (val != other.val) return false;
-		else                  return true;
+		return true;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/data/Either.java b/src/main/java/bjc/data/Either.java
index 42d2e99..07845f6 100644
--- a/src/main/java/bjc/data/Either.java
+++ b/src/main/java/bjc/data/Either.java
@@ -185,6 +185,14 @@ public class Either<LeftType, RightType> {
 		return rightVal;
 	}
 
+	/**
+	 * Change the type of the right-side of this either.
+	 * 
+	 * Works only for left Eithers.
+	 * 
+	 * @param <T> The new type for the right side
+	 * @return The either with the new type.
+	 */
 	@SuppressWarnings("unchecked")
 	public <T> Either<LeftType, T> newRight() {
 		if (isLeft) return (Either<LeftType, T>) this;
@@ -192,6 +200,14 @@ public class Either<LeftType, RightType> {
 		throw new NoSuchElementException("Can't replace right type on right Either");
 	}
 	
+	/**
+	 * Change the type of the left-side of this either.
+	 * 
+	 * Works only for right Eithers.
+	 * 
+	 * @param <T> The new type for the left side
+	 * @return The either with the new type.
+	 */
 	@SuppressWarnings("unchecked")
 	public <T> Either<T, RightType> newLeft() {
 		if (isLeft) 
@@ -199,6 +215,14 @@ public class Either<LeftType, RightType> {
 		return (Either<T, RightType>) this;
 	}
 	
+	/**
+	 * Collapse an Either with the same type on both sides.
+	 * 
+	 * @param <T> The type of the either
+	 * @param eth The either to collapse
+	 * 
+	 * @return The collapsed either
+	 */
 	public static <T> T collapse(Either<T, T> eth) {
 		return eth.extract(ID.id(), ID.id());
 	}
diff --git a/src/main/java/bjc/data/Lazy.java b/src/main/java/bjc/data/Lazy.java
index 45293e2..436e4c3 100644
--- a/src/main/java/bjc/data/Lazy.java
+++ b/src/main/java/bjc/data/Lazy.java
@@ -87,10 +87,7 @@ public class Lazy<ContainedType> implements Holder<ContainedType> {
 		}
 		
 
-		final Supplier<ContainedType> supplier = () -> {
-			if (valueMaterialized) return heldValue;
-			else                   return valueSupplier.get();
-		};
+		final Supplier<ContainedType> supplier = () -> valueMaterialized ? heldValue : valueSupplier.get();
 
 		return new BoundLazy<>(() -> new Lazy<>(supplier, pendingActions), binder);
 	}
@@ -128,18 +125,18 @@ public class Lazy<ContainedType> implements Holder<ContainedType> {
 		if (valueMaterialized) {
 			if (actions.isEmpty()) {
 				return String.format("value[v='%s']", heldValue);
-			} else {
-				return String.format("value[v='%s'] (has %d pending transforms)",
-						heldValue, actions.getSize());
 			}
+			
+			return String.format("value[v='%s'] (has %d pending transforms)",
+					heldValue, actions.getSize());
 		}
 
 		if (actions.isEmpty()) {
 			return"(unmaterialized)";
-		} else {
-			return String.format("(unmaterialized; has %d pending transforms",
-					actions.getSize());
 		}
+		
+		return String.format("(unmaterialized; has %d pending transforms",
+				actions.getSize());
 	}
 
 	@Override
diff --git a/src/main/java/bjc/data/OneWayToggle.java b/src/main/java/bjc/data/OneWayToggle.java
index 0705344..c427af3 100644
--- a/src/main/java/bjc/data/OneWayToggle.java
+++ b/src/main/java/bjc/data/OneWayToggle.java
@@ -57,8 +57,7 @@ public class OneWayToggle<E> implements Toggle<E> {
 
 	@Override
 	public E peek() {
-		if (gotFirst) return second;
-		else          return first;
+		return gotFirst ? second : first;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/data/Pair.java b/src/main/java/bjc/data/Pair.java
index fe65936..dd6ff7c 100644
--- a/src/main/java/bjc/data/Pair.java
+++ b/src/main/java/bjc/data/Pair.java
@@ -268,6 +268,15 @@ public interface Pair<LeftType, RightType> extends Bifunctor<LeftType, RightType
 		return new SimplePair<>(left, right);
 	}
 	
+	/**
+	 * Swap the left & right sides of this pair
+	 * 
+	 * @return The pair with the left and right types swapped
+	 */
+	public default Pair<RightType, LeftType> swap() {
+		return merge((l, r) -> Pair.pair(r, l));
+	}
+	
 	@Override
 	default void formatTo(Formatter formatter, int flags, int width, int precision) {
 		if ((flags & FormattableFlags.ALTERNATE) != 0) {
diff --git a/src/main/java/bjc/data/PetriNet.java b/src/main/java/bjc/data/PetriNet.java
index b4c08e1..2dea6d6 100644
--- a/src/main/java/bjc/data/PetriNet.java
+++ b/src/main/java/bjc/data/PetriNet.java
@@ -31,11 +31,19 @@ public class PetriNet<Label> {
 	private Map<Label, Integer> nodes;
 	private Map<Label, PetriTransition<Label>> transitions;
 
+	/**
+	 * Create a new Petri net
+	 */
 	public PetriNet() {
 		nodes = new HashMap<>();
 		transitions = new HashMap<>();
 	}
 
+	/**
+	 * Merge this Petri net for another.
+	 * 
+	 * @param net The other Petri net.
+	 */
 	public void merge(PetriNet<Label> net) {
 		for (Entry<Label, Integer> node : net.nodes.entrySet()) {
 			int value = node.getValue();
@@ -50,6 +58,15 @@ public class PetriNet<Label> {
 		}
 	}
 	
+	/**
+	 * Create a Petri net from merging others.
+	 * 
+	 * @param <Label> The type of the labels in the Petri net
+	 * @param nets The nets to merge
+	 * 
+	 * @return A net formed by merging all of the provided ones.
+	 */
+	@SafeVarargs
 	public static <Label> PetriNet<Label> merged(PetriNet<Label>... nets) {
 		PetriNet<Label> result = new PetriNet<>();
 
diff --git a/src/main/java/bjc/data/PetriTransition.java b/src/main/java/bjc/data/PetriTransition.java
index 79f879d..6aba5a5 100644
--- a/src/main/java/bjc/data/PetriTransition.java
+++ b/src/main/java/bjc/data/PetriTransition.java
@@ -20,12 +20,22 @@ package bjc.data;
 import java.util.*;
 import java.util.Map.Entry;
 
+/**
+ * Represents a transition in a Petri net
+ * @author bjcul
+ *
+ * @param <Label> The type of the label
+ */
 public class PetriTransition<Label> {
 	private final Label name;
 
 	private Map<Label, Integer> sources;
 	private Map<Label, Integer> destinations;
 
+	/**
+	 * Create a new transition
+	 * @param name The name for this transition
+	 */
 	public PetriTransition(Label name) {
 		this.name = name;
 
@@ -33,22 +43,54 @@ public class PetriTransition<Label> {
 		destinations = new HashMap<>();
 	}
 
+	/**
+	 * Add a source to this transition
+	 * 
+	 * @param lab The label to move from
+	 * @param tokens The number of tokens to move
+	 */
 	public void addSource(Label lab, int tokens) {
 		sources.merge(lab, tokens, (k, v) -> v + tokens);
 	}
 
+	/**
+	 * Remove a source from this transition
+	 * 
+	 * @param lab The source to remove
+	 * @return The number of tokens that would've been moved
+	 */
 	public int removeSource(Label lab) {
 		return sources.remove(lab);
 	}
 
+	/**
+	 * Add a destination to this transition.
+	 * 
+	 * @param lab The label for the destination
+	 * @param tokens The number of tokens to add
+	 */
 	public void addDestination(Label lab, int tokens) {
 		destinations.merge(lab, tokens, (k, v) -> v + tokens);
 	}
 
-	public int removeDestination(Label lab, int tokens) {
+	/**
+	 * Remove a destination from this transition
+	 * 
+	 * @param lab The destination to remove
+	 * 
+	 * @return The number of tokens which would've moved
+	 */
+	public int removeDestination(Label lab) {
 		return destinations.remove(lab);
 	}
 
+	/**
+	 * Apply this transition to a map
+	 * 
+	 * @param nodes The map to apply the transition to
+	 * 
+	 * @return Whether the transition was successfully applied.
+	 */
 	public boolean apply(Map<Label, Integer> nodes) {
 		Set<Entry<Label, Integer>> debts = new HashSet<>();
 		boolean failed = false;
@@ -100,6 +142,11 @@ public class PetriTransition<Label> {
 		return true;
 	}
 	
+	/**
+	 * Merge this transition with another one
+	 * 
+	 * @param transition The transition to merge
+	 */
 	public void merge(PetriTransition<Label> transition) {
 		for (Entry<Label, Integer> source : transition.sources.entrySet()) {
 			int val = source.getValue();
@@ -133,6 +180,16 @@ public class PetriTransition<Label> {
 				&& Objects.equals(sources, other.sources);
 	}
 
+	/**
+	 * Create a transition from merging a bunch
+	 * 
+	 * @param <Label> The type of the label
+	 * 
+	 * @param mergeName The label for the merged transition
+	 * @param transitions The transitions to merge
+	 * 
+	 * @return A transition created by merging the given ones
+	 */
 	@SafeVarargs
 	public static <Label> PetriTransition<Label> merged(Label mergeName, PetriTransition<Label>... transitions) {
 		PetriTransition<Label> result = new PetriTransition<>(mergeName);
diff --git a/src/main/java/bjc/data/Triple.java b/src/main/java/bjc/data/Triple.java
new file mode 100644
index 0000000..296a169
--- /dev/null
+++ b/src/main/java/bjc/data/Triple.java
@@ -0,0 +1,78 @@
+package bjc.data;
+
+/**
+ * Represents a tuple of three values
+ * @author bjcul
+ *
+ * @param <Left> The type of the first value
+ * @param <Middle> The type of the second value
+ * @param <Right> The type of the third value
+ */
+public interface Triple<Left, Middle, Right> {
+	// TODO: fill this out more; mapping and the like
+	/**
+	 * Get the left value for this triple.
+	 * 
+	 * @return The left value for this triple.
+	 */
+	public Left left();
+	
+	/**
+	 * Get the right value for this triple.
+	 * 
+	 * @return The right value for this triple.
+	 */
+	public Right right();
+
+	/**
+	 * Get the middle value for this triple.
+	 * 
+	 * @return The middle value for this triple.
+	 */
+	public Middle middle();
+	
+	/**
+	 * Create a new triple
+	 * 
+	 * @param <Left> The type for the left
+	 * @param <Middle> The type for the middle
+	 * @param <Right> The type for the right
+	 * 
+	 * @param l The left value
+	 * @param m The middle value
+	 * @param r The right value
+	 * 
+	 * @return A triple of the given values
+	 */
+	public static <Left, Middle, Right> Triple<Left, Middle, Right> of(Left l, Middle m, Right r) {
+		return new SimpleTriple<>(r, m, l);
+	}
+}
+
+final class SimpleTriple<Left, Middle, Right> implements Triple<Left, Middle, Right> {
+	private final Right r;
+	private final Middle m;
+	private final Left l;
+
+	SimpleTriple(Right r, Middle m, Left l) {
+		this.r = r;
+		this.m = m;
+		this.l = l;
+	}
+	
+	
+	@Override
+	public Left left() {
+		return l;
+	}
+
+	@Override
+	public Right right() {
+		return r;
+	}
+
+	@Override
+	public Middle middle() {
+		return m;
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/bjc/data/ValueToggle.java b/src/main/java/bjc/data/ValueToggle.java
index 4e9f7c0..4e72fa6 100644
--- a/src/main/java/bjc/data/ValueToggle.java
+++ b/src/main/java/bjc/data/ValueToggle.java
@@ -54,14 +54,12 @@ public class ValueToggle<E> implements Toggle<E> {
 
 	@Override
 	public E get() {
-		if (alignment.get()) return lft;
-		else                 return rght;
+		return alignment.get() ? lft : rght;
 	}
 
 	@Override
 	public E peek() {
-		if (alignment.peek()) return lft;
-		else                  return rght;
+		return alignment.peek() ? lft : rght;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/esodata/AbbrevMap2.java b/src/main/java/bjc/esodata/AbbrevMap2.java
index 72bd4c8..6605c17 100644
--- a/src/main/java/bjc/esodata/AbbrevMap2.java
+++ b/src/main/java/bjc/esodata/AbbrevMap2.java
@@ -18,6 +18,7 @@
 package bjc.esodata;
 
 import java.util.*;
+import java.util.function.Function;
 
 /**
  * A map that allows you to reference strings by unambiguous abbreviations to
@@ -34,17 +35,64 @@ import java.util.*;
  * @author Ben Culkin
  */
 public class AbbrevMap2 {
+	/**
+	 * Strategy to generate abbreviations for an AbbrevMap.
+	 * @author bjcul
+	 *
+	 */
+	public static interface AbbrevStrategy extends Function<String, List<String>>{
+		// alias iface.
+	}
+	
 	// Stores a mapping from strings, to strings that they could be abbreviations
 	// for
 	private Multimap<String, String> backing;
 
+	private List<AbbrevStrategy> strategies;
+	
+	/**
+	 * Strategy which generates abbreviations as all of the prefixes of a word
+	 */
+	public static final AbbrevStrategy INITIAL = (word) -> {
+		List<String> retList = new ArrayList<>();
+
+		int len = word.length();
+
+		for (int i = 1; i <= len; i++) {
+			String substr = word.substring(0, i);
+
+			retList.add(substr);
+		}
+
+		return retList;
+	};
+	
+	/**
+	 * Strategy which converts a camel-case word into the letters of its components.
+	 */
+	public static final AbbrevStrategy CAMELCASE = (word) -> {
+		List<String> retList = new ArrayList<>();
+		// TODO implement a thing
+		return retList;
+	};
+	
 	/**
 	 * Create a new abbreviation map.
 	 */
 	public AbbrevMap2() {
-		backing = new TSetMultimap<>();
+		this(INITIAL);
 	}
 
+	/**
+	 * Create a new abbreviation map.
+	 * 
+	 * @param strategies The strategies to use to generate abbreviations.
+	 */
+	public AbbrevMap2(AbbrevStrategy... strategies) {
+		this.backing = new TSetMultimap<>();
+		this.strategies = List.of(strategies);
+	}
+	
 	/**
 	 * Add words to the map.
 	 *
@@ -58,15 +106,11 @@ public class AbbrevMap2 {
 	}
 
 	// Generate all of the strings a given word could be abbreviated as
-	private static List<String> genAbbrevs(String word) {
+	private List<String> genAbbrevs(String word) {
 		List<String> retList = new ArrayList<>();
 
-		int len = word.length();
-
-		for (int i = 1; i <= len; i++) {
-			String substr = word.substring(0, i);
-
-			retList.add(substr);
+		for (AbbrevStrategy strategy : strategies) {
+			retList.addAll(strategy.apply(word));
 		}
 
 		return retList;
@@ -88,9 +132,9 @@ public class AbbrevMap2 {
 	 * Get all of the strings that a string could be an abbreviation for.
 	 *
 	 * @param word
-	 *             The word to attempt to deabbreviate.
+	 *             The word to attempt to de-abbreviate.
 	 *
-	 * @return All of the possible deabbreviations for that word.
+	 * @return All of the possible de-abbreviations for that word.
 	 */
 	public Set<String> deabbrevAll(String word) {
 		return backing.get(word);
@@ -100,15 +144,16 @@ public class AbbrevMap2 {
 	 * Get the unambiguous thing the string is an abbreviation for.
 	 *
 	 * @param word
-	 *             The word to attempt to deabbreviate.
+	 *             The word to attempt to de-abbreviate.
 	 *
-	 * @return The unambiguous deabbreviation of the string, or null if there isn't
+	 * @return The unambiguous de-abbreviation of the string, or null if there isn't
 	 *         one.
 	 */
 	public String deabbrev(String word) {
 		Set<String> st = backing.get(word);
 
 		if (st.size() == 1) return st.iterator().next();
-		else                return null;
+		
+		return null;
 	}
 }
diff --git a/src/main/java/bjc/esodata/ClosedSpoolException.java b/src/main/java/bjc/esodata/ClosedSpoolException.java
new file mode 100644
index 0000000..ed94222
--- /dev/null
+++ b/src/main/java/bjc/esodata/ClosedSpoolException.java
@@ -0,0 +1,48 @@
+package bjc.esodata;
+
+/**
+ * Exception thrown for attempting to do something with a closed spool that you
+ * should not have.
+ * 
+ * @author bjcul
+ *
+ */
+public class ClosedSpoolException extends RuntimeException {
+	private static final long serialVersionUID = 2846671972910718257L;
+
+	/**
+	 * Create a new default closed spool exception
+	 */
+	public ClosedSpoolException() {
+		super();
+	}
+
+	/**
+	 * Create a new closed spool exception with a given message and cause.
+	 * 
+	 * @param message The message for the exception.
+	 * @param cause   The cause of the exception.
+	 */
+	public ClosedSpoolException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	/**
+	 * Create a new closed spool exception with a given message.
+	 * 
+	 * @param message The message for the exception
+	 */
+	public ClosedSpoolException(String message) {
+		super(message);
+	}
+
+	/**
+	 * Create a new closed spool exception with a given cause.
+	 * 
+	 * @param cause The cause for the exception.
+	 */
+	public ClosedSpoolException(Throwable cause) {
+		super(cause);
+	}
+
+}
diff --git a/src/main/java/bjc/esodata/ComplexSpooler.java b/src/main/java/bjc/esodata/ComplexSpooler.java
new file mode 100644
index 0000000..095527a
--- /dev/null
+++ b/src/main/java/bjc/esodata/ComplexSpooler.java
@@ -0,0 +1,43 @@
+package bjc.esodata;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+/**
+ * Implementation of {@link Spooler} which supports a number of additional features.
+ * 
+ * @author bjcul
+ *
+ * @param <T> The type of data contained on the spools
+ */
+public class ComplexSpooler<T> implements Spooler<T> {
+	private Queue<Spool<T>> pendingAnonSpools;
+	private Map<String, Queue<Spool<T>>> pendingGroupedSpools;
+	
+	private Map<String, Spool<T>> labelledSpools;
+	
+	@Override
+	public void registerSpool(Spool<T> spool) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public Consumer<T> getInput() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Iterator<T> getOutput() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Spool<T> getSpool() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}
diff --git a/src/main/java/bjc/esodata/DefaultList.java b/src/main/java/bjc/esodata/DefaultList.java
index 727eafd..cde6ed4 100644
--- a/src/main/java/bjc/esodata/DefaultList.java
+++ b/src/main/java/bjc/esodata/DefaultList.java
@@ -108,7 +108,8 @@ public class DefaultList<ValueType> extends AbstractList<ValueType> {
 	@Override
 	public ValueType get(int idx) {
 		if (idx < 0 || idx >= backing.size()) return defVal;
-		else                                  return backing.get(idx);
+		
+		return backing.get(idx);
 	}
 
 	@Override
diff --git a/src/main/java/bjc/esodata/DefaultSpool.java b/src/main/java/bjc/esodata/DefaultSpool.java
new file mode 100644
index 0000000..372275d
--- /dev/null
+++ b/src/main/java/bjc/esodata/DefaultSpool.java
@@ -0,0 +1,80 @@
+package bjc.esodata;
+
+import java.util.Iterator;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.function.Consumer;
+
+/**
+ * A default implementation of {@link Spool} using a {@link LinkedBlockingDeque}
+ * as the backing storage.
+ * 
+ * @author bjcul
+ *
+ * @param <T> The type contained in the spool
+ */
+public class DefaultSpool<T> implements Spool<T>, AutoCloseable {
+	private String label;
+	private String group;
+
+	private BlockingQueue<T> container;
+
+	private boolean closed;
+
+	/**
+	 * Create a new spool without label or group
+	 */
+	public DefaultSpool() {
+		this(null, null);
+	}
+
+	/**
+	 * Create a new spool with a given label and group.
+	 * 
+	 * @param label The label of the spool
+	 * @param group The group for the spool
+	 */
+	public DefaultSpool(String label, String group) {
+		this.label = label;
+		this.group = group;
+
+		this.container = new LinkedBlockingDeque<>();
+		this.closed = false;
+	}
+
+	@Override
+	public String label() {
+		return label;
+	}
+
+	@Override
+	public String group() {
+		return group;
+	}
+
+	@Override
+	public Consumer<T> getInput() {
+		return (val) -> {
+			if (closed) {
+				throw new ClosedSpoolException();
+			}
+			container.add(val);
+		};
+	}
+
+	@Override
+	public Iterator<T> getOutput() {
+		return container.iterator();
+	}
+
+	@Override
+	public boolean isClosed() {
+		return false;
+	}
+
+	@Override
+	public void close() throws Exception {
+		closed = true;
+	}
+
+}
diff --git a/src/main/java/bjc/esodata/DefaultSpooler.java b/src/main/java/bjc/esodata/DefaultSpooler.java
new file mode 100644
index 0000000..8ac7891
--- /dev/null
+++ b/src/main/java/bjc/esodata/DefaultSpooler.java
@@ -0,0 +1,43 @@
+package bjc.esodata;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+/**
+ * A default implementation of {@link Spooler} that handles spools in a FIFO manner
+ * @author bjcul
+ *
+ * @param <T> The type contained in the spools.
+ */
+public class DefaultSpooler<T> implements Spooler<T> {
+	private Queue<Spool<T>> spools;
+	
+	/**
+	 * Create a new default spooler.
+	 */
+	public DefaultSpooler() {
+		this.spools = new ArrayDeque<>();
+	}
+	
+	@Override
+	public void registerSpool(Spool<T> spool) {
+		spools.add(spool);
+	}
+
+	@Override
+	public Consumer<T> getInput() {
+		Spool<T> spool = new DefaultSpool<>();
+		registerSpool(spool);
+		return spool.getInput();
+	}
+
+	@Override
+	public Iterator<T> getOutput() {
+		return spools.remove().getOutput();
+	}
+
+	@Override
+	public Spool<T> getSpool() {
+		return spools.remove();
+	}
+}
diff --git a/src/main/java/bjc/esodata/KeyedList.java b/src/main/java/bjc/esodata/KeyedList.java
index 5b0d6cc..5a381e1 100644
--- a/src/main/java/bjc/esodata/KeyedList.java
+++ b/src/main/java/bjc/esodata/KeyedList.java
@@ -19,12 +19,23 @@ package bjc.esodata;
 
 import java.util.*;
 
+/**
+ * Implements a keyed list.
+ * 
+ * @author bjcul
+ *
+ * @param <Key> The type of the key
+ * @param <Val> The type of the value
+ */
 public class KeyedList<Key, Val> implements Iterable<Val> {
 	private List<Val> backing;
 	private Map<Key, Integer> indices;
 
 	private int currIdx = 0;
 
+	/**
+	 * Create a new keyed list
+	 */
 	public KeyedList() {
 		backing = new ArrayList<>();
 		indices = new HashMap<>();
diff --git a/src/main/java/bjc/esodata/Multimap.java b/src/main/java/bjc/esodata/Multimap.java
index d0c0b4b..e9c19bb 100644
--- a/src/main/java/bjc/esodata/Multimap.java
+++ b/src/main/java/bjc/esodata/Multimap.java
@@ -97,6 +97,11 @@ public interface Multimap<KeyType, ValueType> {
 	 */
 	boolean contains(KeyType key, ValueType value);
 
+	/**
+	 * Retrieve an iterator over the values in this map
+	 * 
+	 * @return An iterator over the values in this map
+	 */
 	Iterator<Pair<KeyType, ValueType>> iterator();
 
 }
\ No newline at end of file
diff --git a/src/main/java/bjc/esodata/NestList.java b/src/main/java/bjc/esodata/NestList.java
index c1544ca..d45229f 100644
--- a/src/main/java/bjc/esodata/NestList.java
+++ b/src/main/java/bjc/esodata/NestList.java
@@ -345,10 +345,10 @@ public class NestList<Element> extends AbstractList<Either<Element, NestList<Ele
 											subst.addItem(sublist);
 										}
 								}));
-					} else {
-						state.addItem(list);
-						return state;
 					}
+					
+					state.addItem(list);
+					return state;
 		});
 	}
 	// List methods and other things.
diff --git a/src/main/java/bjc/esodata/PushdownMap.java b/src/main/java/bjc/esodata/PushdownMap.java
index a6e153c..e9ff4de 100644
--- a/src/main/java/bjc/esodata/PushdownMap.java
+++ b/src/main/java/bjc/esodata/PushdownMap.java
@@ -163,9 +163,9 @@ public class PushdownMap<KeyType, ValueType> implements MapEx<KeyType, ValueType
 		if (thawEnabled) {
 			isFrozen = false;
 			return true;
-		} else {
-			return false;
 		}
+		
+		return false;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/esodata/Spool.java b/src/main/java/bjc/esodata/Spool.java
new file mode 100644
index 0000000..f065093
--- /dev/null
+++ b/src/main/java/bjc/esodata/Spool.java
@@ -0,0 +1,48 @@
+package bjc.esodata;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+/**
+ * A single spool, or batch of input.
+ * 
+ * @author bjcul
+ * 
+ * @param <T> The type contained by the spool
+ */
+public interface Spool<T> {
+	/**
+	 * Get the label that identifies this spool, if it has one.
+	 * 
+	 * @return The label of the spool, or null if it is unlabeled.
+	 */
+	public String label();
+
+	/**
+	 * Get the group that this spool belongs to, if it belongs to one.
+	 * 
+	 * @return The group the spool is in, or null if it is not in a group.
+	 */
+	public String group();
+
+	/**
+	 * Get a function that will add input to this spool
+	 * 
+	 * @return A function that will add input to this spool.
+	 */
+	public Consumer<T> getInput();
+
+	/**
+	 * Get an iterator that will iterate over the data contained in this spool.
+	 * 
+	 * @return An iterator over the data in this spool.
+	 */
+	public Iterator<T> getOutput();
+
+	/**
+	 * Is this spool closed, meaning it can accept no more input?
+	 * 
+	 * @return Whether the spool is closed
+	 */
+	public boolean isClosed();
+}
\ No newline at end of file
diff --git a/src/main/java/bjc/esodata/Spooler.java b/src/main/java/bjc/esodata/Spooler.java
new file mode 100644
index 0000000..2cf415a
--- /dev/null
+++ b/src/main/java/bjc/esodata/Spooler.java
@@ -0,0 +1,42 @@
+package bjc.esodata;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+/**
+ * Represents a 'spool' facility for gathering batches of input together to be
+ * processed.
+ * 
+ * @author bjcul
+ *
+ * @param <T> The type of data held in the spools
+ */
+public interface Spooler<T> {
+	/**
+	 * Register a pre-existing spool with this spooler.
+	 * 
+	 * @param spool The spool to register
+	 */
+	public void registerSpool(Spool<T> spool);
+	
+	/**
+	 * Get a consumer belonging to a new anonymous spool.
+	 * 
+	 * @return A new anonymous spool.
+	 */
+	public Consumer<T> getInput();
+	
+	/**
+	 * Get the output for a unprocessed spool.
+	 * 
+	 * @return The output for a unprocessed spool.
+	 */
+	public Iterator<T> getOutput();
+	
+	/**
+	 * Get an unprocessed spool.
+	 * 
+	 * @return An unprocessed spool
+	 */
+	public Spool<T> getSpool();
+}
diff --git a/src/main/java/bjc/esodata/TSetMultimap.java b/src/main/java/bjc/esodata/TSetMultimap.java
index 1a04a41..6c925ab 100644
--- a/src/main/java/bjc/esodata/TSetMultimap.java
+++ b/src/main/java/bjc/esodata/TSetMultimap.java
@@ -94,7 +94,8 @@ public class TSetMultimap<KeyType, ValueType> implements Iterable<Pair<KeyType,
 	@Override
 	public Set<ValueType> get(KeyType key) {
 		if (!backing.containsKey(key)) return new HashSet<>();
-		else                           return backing.get(key).values();
+		
+		return backing.get(key).values();
 	}
 
 	@Override
diff --git a/src/main/java/bjc/esodata/TapeLibrary.java b/src/main/java/bjc/esodata/TapeLibrary.java
index 5fec28a..3794dd5 100644
--- a/src/main/java/bjc/esodata/TapeLibrary.java
+++ b/src/main/java/bjc/esodata/TapeLibrary.java
@@ -132,9 +132,9 @@ public class TapeLibrary<ElementType> implements TapeView<ElementType>
 						(ignored) -> new SingleTape<>());
 			
 			return true;
-		} else {
-			return false;
 		}
+		
+		return false;
 	}
 	
 	/**
diff --git a/src/main/java/bjc/esodata/spool/Spool.java b/src/main/java/bjc/esodata/spool/Spool.java
deleted file mode 100644
index 80e8a8c..0000000
--- a/src/main/java/bjc/esodata/spool/Spool.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/* 
- * esodata - data structures and other things, of varying utility
- * Copyright 2022, Ben Culkin
- * 
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *   
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package bjc.esodata.spool;
-
-public interface Spool<Contained> {
-
-}
diff --git a/src/main/java/bjc/esodata/spool/Spooler.java b/src/main/java/bjc/esodata/spool/Spooler.java
deleted file mode 100644
index 133df2e..0000000
--- a/src/main/java/bjc/esodata/spool/Spooler.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/* 
- * esodata - data structures and other things, of varying utility
- * Copyright 2022, Ben Culkin
- * 
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *   
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package bjc.esodata.spool;
-
-public interface Spooler {
-	public <E> Spool<E> getSpool();
-}
diff --git a/src/main/java/bjc/funcdata/ExtendedMap.java b/src/main/java/bjc/funcdata/ExtendedMap.java
index 4bee343..800cfaa 100644
--- a/src/main/java/bjc/funcdata/ExtendedMap.java
+++ b/src/main/java/bjc/funcdata/ExtendedMap.java
@@ -66,7 +66,8 @@ class ExtendedMap<KeyType, ValueType> implements MapEx<KeyType, ValueType> {
 	@Override
 	public boolean containsKey(final KeyType key) {
 		if (store.containsKey(key)) return true;
-		else                        return delegate.containsKey(key);
+		
+		return delegate.containsKey(key);
 	}
 
 	@Override
@@ -79,7 +80,8 @@ class ExtendedMap<KeyType, ValueType> implements MapEx<KeyType, ValueType> {
 	@Override
 	public Optional<ValueType> get(final KeyType key) {
 		if (store.containsKey(key)) return store.get(key);
-		else                        return delegate.get(key);
+		
+		return delegate.get(key);
 	}
 
 	@Override
@@ -111,7 +113,8 @@ class ExtendedMap<KeyType, ValueType> implements MapEx<KeyType, ValueType> {
 			throw new ObjectFrozen("Can't remove key " + key + " from frozen map");
 		
 		if (!store.containsKey(key)) return delegate.remove(key);
-		else                         return store.remove(key);
+		
+		return store.remove(key);
 	}
 
 	@Override
@@ -159,9 +162,9 @@ class ExtendedMap<KeyType, ValueType> implements MapEx<KeyType, ValueType> {
 		if (thawEnabled) {
 			isFrozen = false;
 			return true;
-		} else {
-			return false;
 		}
+		
+		return false;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/funcdata/Freezable.java b/src/main/java/bjc/funcdata/Freezable.java
index c337509..c4bd27d 100644
--- a/src/main/java/bjc/funcdata/Freezable.java
+++ b/src/main/java/bjc/funcdata/Freezable.java
@@ -28,6 +28,7 @@ package bjc.funcdata;
  * you attempt to modify a frozen object, but they may also choose not to.
  * 
  * @author Ben Culkin
+ * @param <F> The type of the implementing object
  */
 public interface Freezable<F extends Freezable<?>> {
 	/**
diff --git a/src/main/java/bjc/funcdata/FunctionalMap.java b/src/main/java/bjc/funcdata/FunctionalMap.java
index 33a97e6..aec4d28 100644
--- a/src/main/java/bjc/funcdata/FunctionalMap.java
+++ b/src/main/java/bjc/funcdata/FunctionalMap.java
@@ -95,9 +95,9 @@ public class FunctionalMap<KeyType, ValueType> implements MapEx<KeyType, ValueTy
 
 		if (wrappedMap.containsKey(key)) {
 			return Optional.of(wrappedMap.get(key));
-		} else {
-			return Optional.empty();
 		}
+		
+		return Optional.empty();
 	}
 
 	@Override
@@ -172,9 +172,9 @@ public class FunctionalMap<KeyType, ValueType> implements MapEx<KeyType, ValueTy
 		if (thawEnabled) {
 			isFrozen = false;
 			return true;			
-		} else {
-			return false;
 		}
+		
+		return false;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/funcdata/MapEx.java b/src/main/java/bjc/funcdata/MapEx.java
index 1dad1dc..b25960a 100644
--- a/src/main/java/bjc/funcdata/MapEx.java
+++ b/src/main/java/bjc/funcdata/MapEx.java
@@ -31,7 +31,7 @@ import java.util.function.*;
  * @param <ValueType>
  *                    The type of this map's values.
  */
-public interface MapEx<KeyType, ValueType> extends Freezable {
+public interface MapEx<KeyType, ValueType> extends Freezable<MapEx<KeyType, ValueType>> {
 	/**
 	 * Execute an action for each entry in the map.
 	 *
diff --git a/src/main/java/bjc/funcdata/TransformedValueMap.java b/src/main/java/bjc/funcdata/TransformedValueMap.java
index 57fe155..cd75f4a 100644
--- a/src/main/java/bjc/funcdata/TransformedValueMap.java
+++ b/src/main/java/bjc/funcdata/TransformedValueMap.java
@@ -123,9 +123,9 @@ final class TransformedValueMap<OldKey, OldValue, NewValue>
 		if (thawEnabled) {
 			isFrozen = false;
 			return true;
-		} else {
-			return false;
 		}
+		
+		return false;
 	}
 
 	@Override
diff --git a/src/main/java/bjc/functypes/Combinators.java b/src/main/java/bjc/functypes/Combinators.java
index 14af611..ad17975 100644
--- a/src/main/java/bjc/functypes/Combinators.java
+++ b/src/main/java/bjc/functypes/Combinators.java
@@ -347,4 +347,21 @@ public class Combinators {
 	public static <Input> Consumer<Holder<Input>> mutating(UnaryOperator<Input> f) {
 		return (hld) -> hld.transform(f);
 	}
+	
+	/**
+	 * Splat a function so that it is applied to many arguments at once.
+	 * 
+	 * @param <Input> The input type
+	 * @param <Output> The output type
+	 * 
+	 * @param f The function
+	 * @return A splatted variant of the function
+	 */
+	public static <Input, Output> VarArgFunction<Input, Output> splat(Function<Input, Output> f) {
+		return (vals) -> {
+			List<Output> ret = new ArrayList<>(vals.length);
+			for (Input val : vals) ret.add(f.apply(val));
+			return ret;
+		};
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/bjc/functypes/Const.java b/src/main/java/bjc/functypes/Const.java
index 2fc1606..4c3d498 100644
--- a/src/main/java/bjc/functypes/Const.java
+++ b/src/main/java/bjc/functypes/Const.java
@@ -2,6 +2,14 @@ package bjc.functypes;
 
 import bjc.typeclasses.Container;
 
+/**
+ * Represents a constant container
+ * 
+ * @author bjcul
+ *
+ * @param <V> The type of the value
+ * @param <A> The ignored argument type
+ */
 public class Const<V, A> implements Container<V, Const<V, ?>>{
 	private V payload;
 	
@@ -9,6 +17,16 @@ public class Const<V, A> implements Container<V, Const<V, ?>>{
 		this.payload = payload;
 	}
 	
+	/**
+	 * Create a constant container.
+	 * 
+	 * @param <V> The value contained
+	 * @param <A> The ignored argument type
+	 * 
+	 * @param val The type of the value
+	 * 
+	 * @return A constant container giving the contained value
+	 */
 	public static <V, A> Const<V, A> of(V val) {
 		return new Const<>(val);
 	}
diff --git a/src/main/java/bjc/functypes/Predicates.java b/src/main/java/bjc/functypes/Predicates.java
index 3977294..7c670ea 100644
--- a/src/main/java/bjc/functypes/Predicates.java
+++ b/src/main/java/bjc/functypes/Predicates.java
@@ -18,9 +18,6 @@
  */
 package bjc.functypes;
 
-import java.util.function.BiPredicate;
-import java.util.function.Predicate;
-
 /**
  * Various utility functions for predicates
  * @author bjcul
diff --git a/src/main/java/bjc/functypes/ThrowFunction.java b/src/main/java/bjc/functypes/ThrowFunction.java
index 5c61161..084b156 100644
--- a/src/main/java/bjc/functypes/ThrowFunction.java
+++ b/src/main/java/bjc/functypes/ThrowFunction.java
@@ -73,13 +73,13 @@ public interface ThrowFunction<InputType, ReturnType, ExType extends Throwable>
                 if (clasz.isInstance(ex)) {
                     // Swallow this
                     return handler.apply((ExType) ex);
-                } else {
-                    String msg = "Exception of incorrect type to be handled, only "
-                                             + clasz.getName()
-                                             + " are handled";
-                    
-                    throw new RuntimeException(msg, ex);
                 }
+                
+				String msg = "Exception of incorrect type to be handled, only "
+				                         + clasz.getName()
+				                         + " are handled";
+				
+				throw new RuntimeException(msg, ex);
             }
         };
     }
@@ -122,13 +122,13 @@ public interface ThrowFunction<InputType, ReturnType, ExType extends Throwable>
 				if (clasz.isInstance(ex)) {
 					// Swallow this
 					return self.apply(rescue.apply(arg, (ExType) ex));
-				} else {
-					String msg = "Exception of incorrect type to be handled, only "
-											 + clasz.getName()
-											 + " are handled";
-					
-					throw new RuntimeException(msg, ex);
 				}
+				
+				String msg = "Exception of incorrect type to be handled, only "
+										 + clasz.getName()
+										 + " are handled";
+				
+				throw new RuntimeException(msg, ex);
 			}
 		});
 	}
diff --git a/src/main/java/bjc/functypes/TriFunction.java b/src/main/java/bjc/functypes/TriFunction.java
index 988b311..4bb2a72 100644
--- a/src/main/java/bjc/functypes/TriFunction.java
+++ b/src/main/java/bjc/functypes/TriFunction.java
@@ -83,10 +83,24 @@ public interface TriFunction<In1, In2, In3, Out> {
 		return (x, y) -> apply(x, y, z);
 	}
 
+	/**
+	 * Partially apply the second argument.
+	 * 
+	 * @param y The value for the second argument
+	 * 
+	 * @return The function w/ the second argument partially applied
+	 */
 	public default BiFunction<In1, In3, Out> partialMiddle(In2 y) {
 		return (x, z) -> apply(x, y, z);
 	}
 
+	/**
+	 * Partially apply the first argument.
+	 * 
+	 * @param x The value for the first argument
+	 * 
+	 * @return The function w/ the first argument partially applied
+	 */
 	public default BiFunction<In2, In3, Out> partialFirst(In1 x) {
 		return (y, z) -> apply(x, y, z);
 	}
diff --git a/src/main/java/bjc/functypes/VarArgFunction.java b/src/main/java/bjc/functypes/VarArgFunction.java
new file mode 100644
index 0000000..a1c3814
--- /dev/null
+++ b/src/main/java/bjc/functypes/VarArgFunction.java
@@ -0,0 +1,22 @@
+package bjc.functypes;
+
+import java.util.List;
+
+/**
+ * Functional interface for a function that takes and returns an array of arguments
+ * @author bjcul
+ *
+ * @param <Input> The argument type
+ * @param <Output> The return type
+ */
+public interface VarArgFunction<Input, Output> {
+	/**
+	 * Apply this function
+	 * 
+	 * @param inputs The inputs to apply it to
+	 * @return The results of applying it
+	 */
+	// It'd certainly be more convenient to have this return an array, but generics
+	// + arrays do not play well together
+	public List<Output> apply(@SuppressWarnings("unchecked") Input... inputs);
+}
diff --git a/src/main/java/bjc/optics/Adapter.java b/src/main/java/bjc/optics/Adapter.java
new file mode 100644
index 0000000..8ad082f
--- /dev/null
+++ b/src/main/java/bjc/optics/Adapter.java
@@ -0,0 +1,15 @@
+package bjc.optics;
+
+import bjc.typeclasses.BiContainer;
+
+/**
+ * A type-invariant adapter
+ * @author bjcul
+ *
+ * @param <From> The source type
+ * @param <To> The destination type
+ */
+public interface Adapter<From, To>
+		extends AdapterX<From, From, To, To>, BiContainer<From, To, Adapter<From, To>> {
+	// TODO: write 'of' function
+}
diff --git a/src/main/java/bjc/optics/AdapterX.java b/src/main/java/bjc/optics/AdapterX.java
new file mode 100644
index 0000000..f037508
--- /dev/null
+++ b/src/main/java/bjc/optics/AdapterX.java
@@ -0,0 +1,89 @@
+/* 
+ * esodata - data structures of varying utility
+ * 
+ * Copyright 2022, Ben Culkin
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *   
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package bjc.optics;
+
+import java.util.function.Function;
+
+/**
+ * An adapter that maps between two sets of types
+ * 
+ * @author bjcul
+ *
+ * @param <F1> The type of the first source
+ * @param <F2> The type of the second source
+ * @param <T1> The type of the first destination
+ * @param <T2> The type of the second destination
+ */
+public interface AdapterX<F1, F2, T1, T2> extends Optic<F1, F2, T1, T2> {
+
+	/**
+	 * Create a source from a destination
+	 * 
+	 * @param source The destination to use
+	 * 
+	 * @return A source corresponding to the destination
+	 */
+	F1 from(T1 source);
+
+	/**
+	 * Create a destination from a source
+	 * 
+	 * @param source The source to use
+	 * 
+	 * @return A destination corresponding to the source
+	 */
+	T2 to(F2 source);
+
+	/**
+	 * Create an adapter from its component parts
+	 * 
+	 * @param <F1> The type of the first source
+	 * @param <F2> The type of the second source
+	 * @param <T1> The type of the first destination
+	 * @param <T2> The type of the second destination
+	 * 
+	 * @param f    The 'from' function
+	 * @param g    The 'to' function
+	 * 
+	 * @return The adapter constructed from the given parts.
+	 */
+	public static <F1, F2, T1, T2> AdapterX<F1, F2, T1, T2> of(Function<T1, F1> f, Function<F2, T2> g) {
+		return new FunctionalAdapterX<>(f, g);
+	}
+}
+
+final class FunctionalAdapterX<W1, W2, P1, P2> implements AdapterX<W1, W2, P1, P2> {
+	private final Function<P1, W1> f;
+	private final Function<W2, P2> g;
+
+	public FunctionalAdapterX(Function<P1, W1> f, Function<W2, P2> g) {
+		this.f = f;
+		this.g = g;
+	}
+
+	@Override
+	public W1 from(P1 source) {
+		return f.apply(source);
+	}
+
+	@Override
+	public P2 to(W2 source) {
+		return g.apply(source);
+	}
+}
diff --git a/src/main/java/bjc/optics/Adapters.java b/src/main/java/bjc/optics/Adapters.java
new file mode 100644
index 0000000..13a9d02
--- /dev/null
+++ b/src/main/java/bjc/optics/Adapters.java
@@ -0,0 +1,47 @@
+/* 
+ * esodata - data structures of varying use
+ * Copyright 2022, Ben Culkin
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *   
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package bjc.optics;
+
+import bjc.data.Pair;
+import bjc.data.Triple;
+
+/**
+ * Various utilities for dealing with adapters
+ * 
+ * @author bjcul
+ *
+ */
+public class Adapters {
+	/**
+	 * Create an adapter between triples and left-nested pairs.
+	 * 
+	 * @param <A1> The first left type
+	 * @param <A2> The second left type
+	 * @param <B1> The first middle type
+	 * @param <B2> The second middle type
+	 * @param <C1> The first right type
+	 * @param <C2> The second right type
+	 * 
+	 * @return An adapter between triples and left-nested pairs
+	 */
+	public static <A1, A2, B1, B2, C1, C2> AdapterX<Triple<A1, B1, C1>, Triple<A2, B2, C2>, Pair<Pair<A1, B1>, C1>,
+			Pair<Pair<A2, B2>, C2>> flatten() {
+		return AdapterX.of((par) -> Triple.of(par.getLeft().getLeft(), par.getLeft().getRight(), par.getRight()),
+				(trp) -> Pair.pair(Pair.pair(trp.left(), trp.middle()), trp.right()));
+	}
+}
diff --git a/src/main/java/bjc/optics/Lens.java b/src/main/java/bjc/optics/Lens.java
index be10eef..e8cab84 100644
--- a/src/main/java/bjc/optics/Lens.java
+++ b/src/main/java/bjc/optics/Lens.java
@@ -17,8 +17,9 @@
  */
 package bjc.optics;
 
-import java.util.function.Function;
-import java.util.function.UnaryOperator;
+import static bjc.optics.Lenses.immutable;
+
+import java.util.function.*;
 
 import bjc.typeclasses.BiContainer;
 
@@ -28,21 +29,22 @@ import bjc.typeclasses.BiContainer;
  * @author bjcul
  *
  * @param <Whole> The item this lens can focus on
- * @param <Part> The field this lens focuses on
+ * @param <Part>  The field this lens focuses on
  */
-public interface Lens<Whole, Part> extends LensX<Whole, Whole, Part, Part>, BiContainer<Whole, Part, Lens<Whole, Part>> {
+public interface Lens<Whole, Part>
+		extends LensX<Whole, Whole, Part, Part>, BiContainer<Whole, Part, Lens<Whole, Part>> {
 	/**
 	 * Modify a given whole using an operation
 	 * 
 	 * @param source The whole to modify.
-	 * @param mod The operation to use for modifying a part
+	 * @param mod    The operation to use for modifying a part
 	 * 
 	 * @return A modified whole
 	 */
 	default Whole modify(Whole source, UnaryOperator<Part> mod) {
 		return set(source, mod.apply(get(source)));
 	}
-	
+
 	/**
 	 * Create a function which sets the part of a given whole.
 	 * 
@@ -53,16 +55,36 @@ public interface Lens<Whole, Part> extends LensX<Whole, Whole, Part, Part>, BiCo
 	default Function<Whole, Whole> setting(Part part) {
 		return (whole) -> set(whole, part);
 	}
-	
+
 	/**
 	 * Lift a function that modifies parts to one that modifies wholes.
 	 * 
 	 * @param f The function which operates on parts
 	 * 
-	 * @return A corresponding function which applies the given modification to a part.
+	 * @return A corresponding function which applies the given modification to a
+	 *         part.
 	 */
 	default Function<Whole, Whole> lift(UnaryOperator<Part> f) {
 		// modify will be more efficient for some lenses
 		return (whole) -> modify(whole, f);
 	}
+
+	/**
+	 * Compose two type-variant lenses together.
+	 * 
+	 * @param <V1>  The first type the second lens focuses on
+	 * @param <V2>  The second type the second lens focuses on.
+	 * 
+	 * @param other The second lens to use.
+	 * 
+	 * @return A lens composed from this one and the given one.
+	 */
+	default <V1> Lens<Whole, V1> compose(Lens<Part, V1> other) {
+		LensX<Whole, Whole, V1, V1> lensX = immutable((whole) -> other.get(get(whole)),
+				(whole, part) -> update(whole, (val2) -> other.set(val2, part)));
+		// Note: if lensX is inlined, then the setter function for the lens has to be
+		// externalized, otherwise type-inference goes BOOM and everything fails.
+		// Should ask on stack overflow why that is
+		return (Lens<Whole, V1>) lensX;
+	}
 }
diff --git a/src/main/java/bjc/optics/LensX.java b/src/main/java/bjc/optics/LensX.java
index d0f83be..02777e2 100644
--- a/src/main/java/bjc/optics/LensX.java
+++ b/src/main/java/bjc/optics/LensX.java
@@ -19,7 +19,6 @@ package bjc.optics;
 
 import static bjc.optics.Lenses.immutable;
 
-import java.util.function.BiFunction;
 import java.util.function.Function;
 
 /**
diff --git a/src/main/java/bjc/optics/Lenses.java b/src/main/java/bjc/optics/Lenses.java
index 6cebc84..aad5571 100644
--- a/src/main/java/bjc/optics/Lenses.java
+++ b/src/main/java/bjc/optics/Lenses.java
@@ -76,7 +76,7 @@ public class Lenses {
 	public static <Part1, Part2> LensX<Holder<Part1>, Holder<Part2>, Part1, Part2> holder() {
 		return immutable((hld) -> hld.getValue(), (hld, val) -> hld.map((vl) -> val));
 	}
-	
+
 	/**
 	 * Create a lens for updating tagged pairs.
 	 * 
@@ -92,7 +92,13 @@ public class Lenses {
 	public static <A, B, T> LensX<Pair<T, A>, Pair<T, B>, A, B> tagged() {
 		return immutable((par) -> par.getRight(), (par, val) -> par.mapRight((vl) -> val));
 	}
-	
+
+	// Not entirely sure what I was thinking when I wrote this. Pretty sure this
+	// would need W1 to be a monoid to make much sense
+	// public static <W1, P1, P2> Lens<W1, Pair<P1, P2>> both(Lens<W1, P1> lhs,
+	// Lens<W1, P2> rhs) {
+	// }
+
 	/**
 	 * Creates a lens which focuses on a piece of internal state.
 	 * 
@@ -107,7 +113,7 @@ public class Lenses {
 		Holder<A> hold = Holder.of(val);
 		return immutable((whole) -> hold.getValue(), (whole, vl) -> hold.map((arg) -> vl));
 	}
-	
+
 	/**
 	 * Creates a lens which focuses on a piece of mutable internal state.
 	 * 
@@ -121,6 +127,17 @@ public class Lenses {
 		Holder<A> hold = Holder.of(val);
 		return mutable((whole) -> hold.getValue(), (whole, vl) -> hold.replace(vl));
 	}
+
+	/**
+	 * Create a lens that focuses on the sign of an integer
+	 * 
+	 * @return A lens that focuses on the sign of an integer
+	 */
+	public static Lens<Integer, Boolean> sign() {
+		LensX<Integer, Integer, Boolean,
+				Boolean> lensX = immutable((num) -> num >= 0, (num, sgn) -> sgn ? Math.abs(num) : -Math.abs(num));
+		return (Lens<Integer, Boolean>) lensX;
+	}
 }
 
 final class FunctionalLensX<W1, W2, P1, P2> implements LensX<W1, W2, P1, P2> {
diff --git a/src/main/java/bjc/optics/Prism.java b/src/main/java/bjc/optics/Prism.java
new file mode 100644
index 0000000..a04939b
--- /dev/null
+++ b/src/main/java/bjc/optics/Prism.java
@@ -0,0 +1,70 @@
+/* 
+ * esodata - data structures of varying utility
+ * Copyright 2022, Ben Culkin
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *   
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package bjc.optics;
+
+import java.util.function.Function;
+
+import bjc.data.Either;
+import bjc.typeclasses.BiContainer;
+
+/**
+ * A type-invariant prism
+ * 
+ * @author bjcul
+ *
+ * @param <Whole> The type of the whole
+ * @param <Part>  The type of the part
+ */
+public interface Prism<Whole, Part>
+		extends PrismX<Whole, Whole, Part, Part>, BiContainer<Whole, Part, Prism<Whole, Part>> {
+
+	/**
+	 * Create a type-invariant prism from its component parts.
+	 * 
+	 * @param <Whole> The type of the whole
+	 * @param <Part>  The type of the part
+	 * 
+	 * @param f       The 'match' function of the prism
+	 * @param g       The 'build' function of the prism
+	 * 
+	 * @return The prism composed of the given parts.
+	 */
+	static <Whole, Part> Prism<Whole, Part> of(Function<Part, Either<Part, Whole>> f, Function<Whole, Part> g) {
+		return new FunctionalPrism<>(g, f);
+	}
+}
+
+final class FunctionalPrism<Whole, Part> implements Prism<Whole, Part> {
+	private final Function<Whole, Part> g;
+	private final Function<Part, Either<Part, Whole>> f;
+
+	public FunctionalPrism(Function<Whole, Part> g, Function<Part, Either<Part, Whole>> f) {
+		this.g = g;
+		this.f = f;
+	}
+
+	@Override
+	public Part build(Whole whole) {
+		return g.apply(whole);
+	}
+
+	@Override
+	public Either<Part, Whole> match(Part part) {
+		return f.apply(part);
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/bjc/optics/PrismX.java b/src/main/java/bjc/optics/PrismX.java
index b4986cf..0f4a0e0 100644
--- a/src/main/java/bjc/optics/PrismX.java
+++ b/src/main/java/bjc/optics/PrismX.java
@@ -17,6 +17,73 @@
  */
 package bjc.optics;
 
+import java.util.function.Function;
+
+import bjc.data.Either;
+
+/**
+ * Represents a Prism, which is a type of optic.
+ * 
+ * TODO: Add better description
+ * 
+ * @author bjcul
+ *
+ * @param <W1> The type of the first whole
+ * @param <W2> The type of the second whole
+ * @param <P1> The type of the first part
+ * @param <P2> The type of the second part
+ */
 public interface PrismX<W1, W2, P1, P2> extends Optic<W1, W2, P1, P2> {
+	/**
+	 * Match against this prism.
+	 * 
+	 * @param part The part to match
+	 * @return Either the matched value or the prism
+	 */
+	Either<P2, W1> match(P1 part);
 
+	/**
+	 * Build this prism from a given part.
+	 * 
+	 * @param whole The whole to build from
+	 * @return The part that is constructed
+	 */
+	P2 build(W2 whole);
+
+	/**
+	 * Create a prism from its component parts
+	 * 
+	 * @param <W1> The type of the first whole
+	 * @param <W2> The type of the second whole
+	 * @param <P1> The type of the first part
+	 * @param <P2> The type of the second part
+	 * 
+	 * @param f The 'match' function for the prism
+	 * @param g The 'build' function for the prism
+	 * 
+	 * @return A prism built from the given parts
+	 */
+	static <W1, W2, P1, P2> PrismX<W1, W2, P1, P2> of(Function<P1, Either<P2, W1>> f, Function<W2, P2> g) {
+		return new FunctionalPrismX<>(g, f);
+	}
 }
+
+final class FunctionalPrismX<W1, W2, P1, P2> implements PrismX<W1, W2, P1, P2> {
+	private final Function<W2, P2> g;
+	private final Function<P1, Either<P2, W1>> f;
+
+	public FunctionalPrismX(Function<W2, P2> g, Function<P1, Either<P2, W1>> f) {
+		this.g = g;
+		this.f = f;
+	}
+
+	@Override
+	public P2 build(W2 whole) {
+		return g.apply(whole);
+	}
+
+	@Override
+	public Either<P2, W1> match(P1 part) {
+		return f.apply(part);
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/bjc/optics/Prisms.java b/src/main/java/bjc/optics/Prisms.java
new file mode 100644
index 0000000..ae4a4ee
--- /dev/null
+++ b/src/main/java/bjc/optics/Prisms.java
@@ -0,0 +1,56 @@
+/* 
+ * esodata - data structures of varying utility
+ * Copyright 2022, Ben Culkin
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *   
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package bjc.optics;
+
+import java.util.Optional;
+
+import bjc.data.Either;
+
+/**
+ * Various utilities for working with prisms
+ * 
+ * @author bjcul
+ *
+ */
+public class Prisms {
+	/**
+	 * Create a prism that reflects on the value in an optional
+	 * 
+	 * @param <L> The type contained in the optional
+	 * @param <R> An auxiliary type
+	 * 
+	 *            TODO: better notes for what R is for
+	 * 
+	 * @return A prism that reflects on an optional
+	 */
+	public static <L, R> PrismX<L, R, Optional<L>, Optional<R>> optional() {
+		return PrismX.of((opt) -> opt.isPresent() ? Either.right(opt.get()) : Either.left(Optional.empty()),
+				Optional::ofNullable);
+	}
+
+	/**
+	 * Create a prism that reflects on whether a double corresponds to a given
+	 * integer.
+	 * 
+	 * @return A prism on the int view of a double.
+	 */
+	public static Prism<Integer, Double> whole() {
+		return Prism.of((vl) -> Math.rint(vl) == vl ? Either.right(vl.intValue()) : Either.left(vl),
+				Integer::doubleValue);
+	}
+}
diff --git a/src/main/java/bjc/optics/Traversal.java b/src/main/java/bjc/optics/Traversal.java
new file mode 100644
index 0000000..a41f2b9
--- /dev/null
+++ b/src/main/java/bjc/optics/Traversal.java
@@ -0,0 +1,14 @@
+package bjc.optics;
+
+import bjc.typeclasses.BiContainer;
+
+/**
+ * A traversal
+ * @author bjcul
+ *
+ * @param <C> The container type
+ * @param <E> The element type
+ */
+public interface Traversal<C, E> extends TraversalX<C, C, E, E>, BiContainer<C, E, Traversal<C, E>> {
+	// TODO implement 'of'
+}
diff --git a/src/main/java/bjc/optics/TraversalX.java b/src/main/java/bjc/optics/TraversalX.java
new file mode 100644
index 0000000..54c1a0b
--- /dev/null
+++ b/src/main/java/bjc/optics/TraversalX.java
@@ -0,0 +1,54 @@
+/* 
+ * esodata - data structures of varying use
+ * Copyright 2022, Ben Culkin
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *   
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package bjc.optics;
+
+import java.util.Collection;
+
+/**
+ * Represents an optic allowing access to the elements of a given item
+ * 
+ * @author bjcul
+ *
+ * @param <C1> The first collection type
+ * @param <C2> The second collection type
+ * @param <E1> The first element type
+ * @param <E2> The second element type
+ */
+public interface TraversalX<C1, C2, E1, E2> extends Optic<C1, C2, E1, E2> {
+	// Note: these should be fixed size collections of the same type, but that would
+	// be awkward to represent
+	/**
+	 * Extract the contents of the collection
+	 * 
+	 * @param whole The collection to get the contents of.
+	 * @return The contents of the given collection.
+	 */
+	Collection<E1> contents(C1 whole);
+
+	/**
+	 * Replace the contents of the given collection
+	 * 
+	 * @param whole The collection to replace the contents of
+	 * @param bits  The new contents of the collection
+	 * 
+	 * @return A collection with the new contents
+	 */
+	C2 fill(C1 whole, Collection<E2> bits);
+	
+	// TODO implement 'of'
+}
diff --git a/src/main/java/bjc/typeclasses/Applicative.java b/src/main/java/bjc/typeclasses/Applicative.java
new file mode 100644
index 0000000..7e70c61
--- /dev/null
+++ b/src/main/java/bjc/typeclasses/Applicative.java
@@ -0,0 +1,39 @@
+package bjc.typeclasses;
+
+import java.util.function.Function;
+
+/**
+ * Represents an applicative
+ * @author bjcul
+ *
+ * @param <A> The contained type
+ * @param <App> The self type
+ */
+public interface Applicative<A, App extends Applicative<?, App>> extends FunctorX<A, App> {
+	/**
+	 * Create an applicative from a value
+	 * 
+	 * @param <B> The type of the value
+	 * 
+	 * @param val The value
+	 * 
+	 * @return An applicative containing the given value
+	 */
+	<B> Applicative<B, App> pure(B val);
+	
+	/**
+	 * Apply the given applicative
+	 * 
+	 * @param <B> The type of the result
+	 * 
+	 * @param func An applicative containing a function
+	 * 
+	 * @return An applicative containing the result of applying the function
+	 */
+	<B> Applicative<B, App> app(Applicative<Function<? super A, ? extends B>, App> func);
+	
+	@Override
+	default <B> FunctorX<B, App> fmap(Function<? super A, ? extends B> fn) {
+		return app(pure(fn));
+	}
+}
diff --git a/src/main/java/bjc/typeclasses/BiContainer.java b/src/main/java/bjc/typeclasses/BiContainer.java
index 9be00ca..4be0200 100644
--- a/src/main/java/bjc/typeclasses/BiContainer.java
+++ b/src/main/java/bjc/typeclasses/BiContainer.java
@@ -17,6 +17,14 @@
  */
 package bjc.typeclasses;
 
+/**
+ * Marker interface for BiContainers
+ * @author bjcul
+ *
+ * @param <L> The left value type
+ * @param <R> The right value type
+ * @param <C> The self type
+ */
 public interface BiContainer<L, R, C extends BiContainer<?, ?, C>> {
 	// marker
 }
diff --git a/src/main/java/bjc/typeclasses/Container.java b/src/main/java/bjc/typeclasses/Container.java
index b1e3e34..76bad31 100644
--- a/src/main/java/bjc/typeclasses/Container.java
+++ b/src/main/java/bjc/typeclasses/Container.java
@@ -17,6 +17,13 @@
  */
 package bjc.typeclasses;
 
+/**
+ * Marker type for containers
+ * @author bjcul
+ *
+ * @param <T> The value type
+ * @param <C> The self type
+ */
 public interface Container<T, C extends Container<?, C>> {
 	// Marker
 }
diff --git a/src/main/java/bjc/typeclasses/FunList.java b/src/main/java/bjc/typeclasses/FunList.java
index cd16c82..78717af 100644
--- a/src/main/java/bjc/typeclasses/FunList.java
+++ b/src/main/java/bjc/typeclasses/FunList.java
@@ -4,10 +4,30 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
 
+/**
+ * Represent a FunList data structure which contains a B and zero or more As
+ * @author bjcul
+ *
+ * @param <A> The type for A
+ * @param <B> The type for B
+ */
 public sealed interface FunList<A, B> permits FunList.Done<A, B>, FunList.More<A, B> {
+	/**
+	 * Represents a FunList that contains a B and zero As
+	 * 
+	 * @author bjcul
+	 *
+	 * @param <A> Unused type 
+	 * @param <B> Type of the contained value
+	 */
 	public final class Done<A, B> implements FunList<A, B> {
 		private final B val;
 
+		/**
+		 * Create a new Done FunList
+		 * 
+		 * @param val The contained value
+		 */
 		public Done(B val) {
 			this.val = val;
 		}
@@ -23,10 +43,23 @@ public sealed interface FunList<A, B> permits FunList.Done<A, B>, FunList.More<A
 		}
 	}
 
+	/**
+	 * A FunList that contains an A and another FunList
+	 * @author bjcul
+	 *
+	 * @param <A> The contained type
+	 * @param <B> The type of the eventual result
+	 */
 	public final class More<A, B> implements FunList<A, B> {
 		private A val;
 		private FunList<A, Function<A, B>> rest;
 
+		/**
+		 * Create a FunList
+		 * 
+		 * @param val The contained value
+		 * @param rest The rest of the list
+		 */
 		public More(A val, FunList<A, Function<A, B>> rest) {
 			this.val = val;
 			this.rest = rest;
@@ -47,9 +80,23 @@ public sealed interface FunList<A, B> permits FunList.Done<A, B>, FunList.More<A
 		}
 	}
 
+	/**
+	 * Get the eventual result
+	 * @return the eventual result
+	 */
 	public B getB();
 
+	/**
+	 * Get the contained arguments
+	 * 
+	 * @return The arguments
+	 */
 	public List<A> getAs();
 	
 	// https://twanvl.nl/blog/haskell/non-regular1
+	
+	// Notes have the following signatures instead
+	// Done<T> extends Holder<T>
+	// More<A, B> extends Pair<A, B>
+	// FunList<A, B, T> extends Either<Done<T>, More<A, FunList<A, B, Function<B, T>>>>
 }
diff --git a/src/main/java/bjc/typeclasses/FunctorX.java b/src/main/java/bjc/typeclasses/FunctorX.java
new file mode 100644
index 0000000..137cc3f
--- /dev/null
+++ b/src/main/java/bjc/typeclasses/FunctorX.java
@@ -0,0 +1,10 @@
+package bjc.typeclasses;
+
+import java.util.function.Function;
+
+// TODO: determine if it makes sense to replace regular Functor w/ this
+public interface FunctorX<A, F extends FunctorX<?, F>> extends Container<A, F> {
+	<B> FunctorX<B, F> fmap(Function<? super A, ? extends B> fn);
+	
+	// Actually no way to write a 'of' function here; the embedded B gets in our way
+}
diff --git a/src/main/java/bjc/typeclasses/ListC.java b/src/main/java/bjc/typeclasses/ListC.java
index 16dca8a..be3d24c 100644
--- a/src/main/java/bjc/typeclasses/ListC.java
+++ b/src/main/java/bjc/typeclasses/ListC.java
@@ -19,13 +19,29 @@ package bjc.typeclasses;
 
 import java.util.List;
 
+/**
+ * A list wrapped in a container
+ * @author bjcul
+ *
+ * @param <T> The type contained
+ */
 public class ListC<T> implements Container<T, ListC<?>> {
 	private List<T> contained;
 	
+	/**
+	 * Create a new contained list
+	 * 
+	 * @param contained The contained list
+	 */
 	public ListC(List<T> contained) {
 		this.contained = contained;
 	}
 	
+	/**
+	 * Retrieve the contained list
+	 * 
+	 * @return The contained list
+	 */
 	public List<T> list() {
 		return contained;
 	}
diff --git a/src/main/java/bjc/typeclasses/PFLens.java b/src/main/java/bjc/typeclasses/PFLens.java
index 0468efb..3574cde 100644
--- a/src/main/java/bjc/typeclasses/PFLens.java
+++ b/src/main/java/bjc/typeclasses/PFLens.java
@@ -7,12 +7,23 @@ import java.util.function.Function;
  * 
  * @author bjcul
  *
- * @param <Whole1>
- * @param <Whole2>
- * @param <Part1>
- * @param <Part2>
+ * @param <Whole1> The first whole
+ * @param <Whole2> The second whole
+ * @param <Part1> The first part
+ * @param <Part2> The second part
  */
 public interface PFLens<Whole1, Whole2, Part1, Part2> {
-	// Container should be Functor once gthat is ironed out
+	// Container should be Functor once that is ironed out
+	/**
+	 * Run the lens in the given functor
+	 * 
+	 * @param <A> First argument 
+	 * @param <B> second argument
+	 * @param <F> Underlying functor
+	 * 
+	 * @param f The function to apply
+	 * 
+	 * @return The result of applying the functor
+	 */
 	<A, B, F extends Container<?, F>> Function<Whole1, Container<Whole2, F>> run(Function<Part1, Container<Part2, F>> f);
 }
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
index edae185..13e211b 100644
--- a/src/main/java/module-info.java
+++ b/src/main/java/module-info.java
@@ -28,4 +28,6 @@ module esodata {
 	exports bjc.funcdata.bst;
 	exports bjc.funcdata.theory;
 	exports bjc.funcdata;
+	exports bjc.typeclasses;
+	exports bjc.optics;
 }
\ No newline at end of file
-- 
cgit v1.2.3