Add a whole bunch of Optics

This adds a whole bunch of types/functions related to optics. With this
batch, I've mainly gone for the concrete representation types, instead
of var Laarhoven or profunctor representations.

The concrete ones require less infrastructure, though they are not as
easy to compose

There's also a number of misc. things in here

25 files changed, 464 insertions, 33 deletions

diff --git a/src/main/java/bjc/data/CollectionUtils.java b/src/main/java/bjc/data/CollectionUtils.java
new file mode 100644
index 0000000..08ef711
--- /dev/null
+++ b/src/main/java/bjc/data/CollectionUtils.java
@@ -0,0 +1,54 @@
+/* 
+ * 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.data;
+
+import java.util.*;
+import java.util.function.Function;
+
+/**
+ * Various utilities for dealing w/ collections
+ * @author bjcul
+ *
+ */
+public class CollectionUtils {
+	/**
+	 * Create a function that converts a collection into a map.
+	 * 
+	 * @param <Val>   The type of the values in the map
+	 * @param <Idx>   The type of the keys in the map
+	 * @param <Ent>   The type of the values in the collection
+	 * 
+	 * @param keyFunc The function that determines keys
+	 * @param valFunc The function that determines values
+	 * 
+	 * @return A function which uses the provided function to create a map from a
+	 *         collection.
+	 */
+	public static <Val, Idx, Ent> Function<Collection<Ent>, Map<Idx, Val>> indexBy(Function<Ent, Idx> keyFunc,
+			Function<Ent, Val> valFunc) {
+		return (coll) -> {
+			Map<Idx, Val> mep = new HashMap<>();
+
+			for (Ent ent : coll) {
+				mep.put(keyFunc.apply(ent), valFunc.apply(ent));
+			}
+
+			return mep;
+		};
+	}
+}
diff --git a/src/main/java/bjc/data/Holder.java b/src/main/java/bjc/data/Holder.java
index 4a1de75..57a5d6c 100644
--- a/src/main/java/bjc/data/Holder.java
+++ b/src/main/java/bjc/data/Holder.java
@@ -26,6 +26,7 @@ import bjc.data.internals.WrappedLazy;
 import bjc.data.internals.WrappedOption;
 import bjc.funcdata.FunctionalList;
 import bjc.funcdata.theory.Functor;
+import bjc.typeclasses.Container;
 
 /**
  * A holder of a single value.
@@ -35,7 +36,8 @@ import bjc.funcdata.theory.Functor;
  * @param <ContainedType>
  *                        The type of value held.
  */
-public interface Holder<ContainedType> extends Functor<ContainedType> {
+public interface Holder<ContainedType> extends Functor<ContainedType>, Container<ContainedType, Holder<ContainedType>> {
+	// note: to really work, this should also take the binding parameter
 	/**
 	 * Bind a function across the value in this container.
 	 *
diff --git a/src/main/java/bjc/functypes/Combinators.java b/src/main/java/bjc/functypes/Combinators.java
index 0b157bb..14af611 100644
--- a/src/main/java/bjc/functypes/Combinators.java
+++ b/src/main/java/bjc/functypes/Combinators.java
@@ -301,14 +301,50 @@ public class Combinators {
 
 	// TODO: write a switch-like combinator that uses a KeyedList to get the desired
 	// fallthrough semantics
-	
+
 	// TODO: non-shortcircuiting boolean combinators
-	
+
+	/**
+	 * Convert a function into one that takes a supplier as its parameter
+	 * 
+	 * Note this is not as useful as the reverse, as we need to evaluate the
+	 * supplier to call the function.
+	 * 
+	 * @param <Input>  The input type
+	 * @param <Output> The output type
+	 * 
+	 * @param f        The function
+	 * 
+	 * @return The function, taking a supplier as its first function
+	 */
 	public static <Input, Output> Function<Supplier<Input>, Output> lazify(Function<Input, Output> f) {
 		return (supp) -> f.apply(supp.get());
 	}
 
+	/**
+	 * Convert a lazy function into an eager one
+	 * 
+	 * @param <Input> The input type
+	 * @param <Output> The output type
+	 * 
+	 * @param f A function that takes a supplier as its parameter
+	 * 
+	 * @return A function which just takes a value
+	 */
 	public static <Input, Output> Function<Input, Output> strictify(Function<Supplier<Input>, Output> f) {
 		return (val) -> f.apply(() -> val);
 	}
+	
+	/**
+	 * Convert a pure function into one that mutates a holder.
+	 * 
+	 * @param <Input> The type of the function.
+	 * 
+	 * @param f The function.
+	 * 
+	 * @return A function that mutates a holder using the given function
+	 */
+	public static <Input> Consumer<Holder<Input>> mutating(UnaryOperator<Input> f) {
+		return (hld) -> hld.transform(f);
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/bjc/functypes/Const.java b/src/main/java/bjc/functypes/Const.java
new file mode 100644
index 0000000..2fc1606
--- /dev/null
+++ b/src/main/java/bjc/functypes/Const.java
@@ -0,0 +1,19 @@
+package bjc.functypes;
+
+import bjc.typeclasses.Container;
+
+public class Const<V, A> implements Container<V, Const<V, ?>>{
+	private V payload;
+	
+	private Const(V payload) {
+		this.payload = payload;
+	}
+	
+	public static <V, A> Const<V, A> of(V val) {
+		return new Const<>(val);
+	}
+	
+	V get() {
+		return payload;
+	}
+}
diff --git a/src/main/java/bjc/functypes/optics/Lens.java b/src/main/java/bjc/functypes/Predicates.java
index c56a016..3977294 100644
--- a/src/main/java/bjc/functypes/optics/Lens.java
+++ b/src/main/java/bjc/functypes/Predicates.java
@@ -1,5 +1,6 @@
 /* 
- * esodata - data structures and other things, of varying utility
+ * esodata - data structures of varying utility
+ * 
  * Copyright 2022, Ben Culkin
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -15,16 +16,26 @@
  * 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.functypes.optics;
+package bjc.functypes;
+
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
 
 /**
- * A type-invariant var Laarhoven lens.
- * 
+ * Various utility functions for predicates
  * @author bjcul
  *
- * @param <Whole> The item this lens can focus on
- * @param <Part> The field this lens focuses on
  */
-public interface Lens<Whole, Part> extends LensX<Whole, Whole, Part, Part> {
-	// Alias type
-}
+public class Predicates {
+	/**
+	 * A predicate for logical implication (!x || y)
+	 * 
+	 * @param x The LHS
+	 * @param y The RHS
+	 * 
+	 * @return Whether the LHS implies the RHS
+	 */
+	public static boolean implies(boolean x, boolean y) {
+		return !x || y;
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/bjc/functypes/ThrowFunction.java b/src/main/java/bjc/functypes/ThrowFunction.java
index 2ec5bea..5c61161 100644
--- a/src/main/java/bjc/functypes/ThrowFunction.java
+++ b/src/main/java/bjc/functypes/ThrowFunction.java
@@ -20,6 +20,8 @@ package bjc.functypes;
 import java.util.*;
 import java.util.function.*;
 
+import bjc.typeclasses.Isomorphism;
+
 /**
  * An instance of {@link Function} that can throw an exception.
  * 
diff --git a/src/main/java/bjc/optics/Lens.java b/src/main/java/bjc/optics/Lens.java
new file mode 100644
index 0000000..be10eef
--- /dev/null
+++ b/src/main/java/bjc/optics/Lens.java
@@ -0,0 +1,68 @@
+/* 
+ * 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.optics;
+
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+import bjc.typeclasses.BiContainer;
+
+/**
+ * A type-invariant var Laarhoven lens.
+ * 
+ * @author bjcul
+ *
+ * @param <Whole> The item this lens can focus 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>> {
+	/**
+	 * Modify a given whole using an operation
+	 * 
+	 * @param source The whole to modify.
+	 * @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.
+	 * 
+	 * @param part The part to set
+	 * 
+	 * @return A function that sets the given part on a whole.
+	 */
+	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.
+	 */
+	default Function<Whole, Whole> lift(UnaryOperator<Part> f) {
+		// modify will be more efficient for some lenses
+		return (whole) -> modify(whole, f);
+	}
+}
diff --git a/src/main/java/bjc/functypes/optics/LensX.java b/src/main/java/bjc/optics/LensX.java
index 0c78370..d0f83be 100644
--- a/src/main/java/bjc/functypes/optics/LensX.java
+++ b/src/main/java/bjc/optics/LensX.java
@@ -15,9 +15,9 @@
  * 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.functypes.optics;
+package bjc.optics;
 
-import static bjc.functypes.optics.Lenses.immutable;
+import static bjc.optics.Lenses.immutable;
 
 import java.util.function.BiFunction;
 import java.util.function.Function;
diff --git a/src/main/java/bjc/functypes/optics/Lenses.java b/src/main/java/bjc/optics/Lenses.java
index 3c4c688..6cebc84 100644
--- a/src/main/java/bjc/functypes/optics/Lenses.java
+++ b/src/main/java/bjc/optics/Lenses.java
@@ -15,7 +15,7 @@
  * 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.functypes.optics;
+package bjc.optics;
 
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
diff --git a/src/main/java/bjc/functypes/optics/MutableLens.java b/src/main/java/bjc/optics/MutableLens.java
index 9c2e635..88eca04 100644
--- a/src/main/java/bjc/functypes/optics/MutableLens.java
+++ b/src/main/java/bjc/optics/MutableLens.java
@@ -15,7 +15,7 @@
  * 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.functypes.optics;
+package bjc.optics;
 
 /**
  * A type-invariant lens for mutating objects.
diff --git a/src/main/java/bjc/functypes/optics/Optic.java b/src/main/java/bjc/optics/Optic.java
index 513e110..389da21 100644
--- a/src/main/java/bjc/functypes/optics/Optic.java
+++ b/src/main/java/bjc/optics/Optic.java
@@ -15,7 +15,7 @@
  * 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.functypes.optics;
+package bjc.optics;
 
 /**
  * General interface for optics of varying sorts
diff --git a/src/main/java/bjc/functypes/optics/PrismX.java b/src/main/java/bjc/optics/PrismX.java
index b62bce3..b4986cf 100644
--- a/src/main/java/bjc/functypes/optics/PrismX.java
+++ b/src/main/java/bjc/optics/PrismX.java
@@ -15,7 +15,7 @@
  * 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.functypes.optics;
+package bjc.optics;
 
 public interface PrismX<W1, W2, P1, P2> extends Optic<W1, W2, P1, P2> {
 
diff --git a/src/main/java/bjc/functypes/optics/impl/package-info.java b/src/main/java/bjc/optics/impl/package-info.java
index 8ca00cf..b147877 100644
--- a/src/main/java/bjc/functypes/optics/impl/package-info.java
+++ b/src/main/java/bjc/optics/impl/package-info.java
@@ -15,4 +15,4 @@
  * 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.functypes.optics.impl;
\ No newline at end of file
+package bjc.optics.impl;
\ No newline at end of file
diff --git a/src/main/java/bjc/functypes/optics/package-info.java b/src/main/java/bjc/optics/package-info.java
index a3f656c..241b565 100644
--- a/src/main/java/bjc/functypes/optics/package-info.java
+++ b/src/main/java/bjc/optics/package-info.java
@@ -18,4 +18,4 @@
 /**
  * 
  */
-package bjc.functypes.optics;
\ No newline at end of file
+package bjc.optics;
\ No newline at end of file
diff --git a/src/main/java/bjc/functypes/BiContainer.java b/src/main/java/bjc/typeclasses/BiContainer.java
index db822ba..9be00ca 100644
--- a/src/main/java/bjc/functypes/BiContainer.java
+++ b/src/main/java/bjc/typeclasses/BiContainer.java
@@ -15,7 +15,7 @@
  * 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.functypes;
+package bjc.typeclasses;
 
 public interface BiContainer<L, R, C extends BiContainer<?, ?, C>> {
 	// marker
diff --git a/src/main/java/bjc/functypes/Container.java b/src/main/java/bjc/typeclasses/Container.java
index f000705..b1e3e34 100644
--- a/src/main/java/bjc/functypes/Container.java
+++ b/src/main/java/bjc/typeclasses/Container.java
@@ -15,7 +15,7 @@
  * 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.functypes;
+package bjc.typeclasses;
 
 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
new file mode 100644
index 0000000..cd16c82
--- /dev/null
+++ b/src/main/java/bjc/typeclasses/FunList.java
@@ -0,0 +1,55 @@
+package bjc.typeclasses;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public sealed interface FunList<A, B> permits FunList.Done<A, B>, FunList.More<A, B> {
+	public final class Done<A, B> implements FunList<A, B> {
+		private final B val;
+
+		public Done(B val) {
+			this.val = val;
+		}
+
+		@Override
+		public B getB() {
+			return val;
+		}
+
+		@Override
+		public List<A> getAs() {
+			return new ArrayList<>();
+		}
+	}
+
+	public final class More<A, B> implements FunList<A, B> {
+		private A val;
+		private FunList<A, Function<A, B>> rest;
+
+		public More(A val, FunList<A, Function<A, B>> rest) {
+			this.val = val;
+			this.rest = rest;
+		}
+
+		@Override
+		public B getB() {
+			return rest.getB().apply(val);
+		}
+
+		@Override
+		public List<A> getAs() {
+			List<A> as = rest.getAs();
+			// Note: this is kinda inefficient. Should we instead say that it returns the As
+			// in reverse order
+			as.add(0, val);
+			return as;
+		}
+	}
+
+	public B getB();
+
+	public List<A> getAs();
+	
+	// https://twanvl.nl/blog/haskell/non-regular1
+}
diff --git a/src/main/java/bjc/functypes/FunctionalIsomorphism.java b/src/main/java/bjc/typeclasses/FunctionalIsomorphism.java
index 43520e3..47d060c 100644
--- a/src/main/java/bjc/functypes/FunctionalIsomorphism.java
+++ b/src/main/java/bjc/typeclasses/FunctionalIsomorphism.java
@@ -15,7 +15,7 @@
  * 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.functypes;
+package bjc.typeclasses;
 
 import java.util.function.Function;
 
diff --git a/src/main/java/bjc/functypes/Isomorphism.java b/src/main/java/bjc/typeclasses/Isomorphism.java
index 3393ed6..dd5a740 100644
--- a/src/main/java/bjc/functypes/Isomorphism.java
+++ b/src/main/java/bjc/typeclasses/Isomorphism.java
@@ -15,7 +15,7 @@
  * 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.functypes;
+package bjc.typeclasses;
 
 import java.util.function.*;
 
diff --git a/src/main/java/bjc/functypes/ListC.java b/src/main/java/bjc/typeclasses/ListC.java
index 78fbb7a..16dca8a 100644
--- a/src/main/java/bjc/functypes/ListC.java
+++ b/src/main/java/bjc/typeclasses/ListC.java
@@ -15,7 +15,7 @@
  * 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.functypes;
+package bjc.typeclasses;
 
 import java.util.List;
 
diff --git a/src/main/java/bjc/functypes/Natural.java b/src/main/java/bjc/typeclasses/Natural.java
index ecf12c4..d487b9a 100644
--- a/src/main/java/bjc/functypes/Natural.java
+++ b/src/main/java/bjc/typeclasses/Natural.java
@@ -15,19 +15,41 @@
  * 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.functypes;
+package bjc.typeclasses;
 
+/**
+ * A natural transformation; a mapping between two type-containers which
+ * preserves the contents of the containers.
+ * 
+ * @author bjcul
+ *
+ * @param <F> The actual type of the first container
+ * @param <G> The actual type of the second container
+ */
 @FunctionalInterface
-public interface Natural<F extends Container<?, F>, G extends Container<?, G>> extends BiContainer<F, G, Natural<?, ?>> {
+public interface Natural<F extends Container<?, F>, G extends Container<?, G>>
+		extends BiContainer<F, G, Natural<?, ?>> {
+	/**
+	 * Apply the natural transformation.
+	 * 
+	 * @param <X> The type contained in the container
+	 * 
+	 * @param val The container to be transformed
+	 * 
+	 * @return The value, in the other container type
+	 */
 	<X> Container<X, G> apply(Container<X, F> val);
 
-	public static Natural<ListC<?>, ListC<?>> listID() {
+	/**
+	 * The simplest possible natural transform, mapping a type to itself.
+	 * 
+	 * @return The ID natural transform
+	 */
+	public static <C extends Container<?, C>> Natural<C, C> ID() {
 		return new Natural<>() {
 			@Override
-			public <X> ListC<X> apply(Container<X, ListC<?>> val) {
-				ListC<X> lst = (ListC<X>) val;
-				
-				return lst;
+			public <X> Container<X, C> apply(Container<X, C> val) {
+				return val;
 			}
 		};
 	}
diff --git a/src/main/java/bjc/typeclasses/PFLens.java b/src/main/java/bjc/typeclasses/PFLens.java
new file mode 100644
index 0000000..0468efb
--- /dev/null
+++ b/src/main/java/bjc/typeclasses/PFLens.java
@@ -0,0 +1,18 @@
+package bjc.typeclasses;
+
+import java.util.function.Function;
+
+/**
+ * A profunctor lens
+ * 
+ * @author bjcul
+ *
+ * @param <Whole1>
+ * @param <Whole2>
+ * @param <Part1>
+ * @param <Part2>
+ */
+public interface PFLens<Whole1, Whole2, Part1, Part2> {
+	// Container should be Functor once gthat is ironed out
+	<A, B, F extends Container<?, F>> Function<Whole1, Container<Whole2, F>> run(Function<Part1, Container<Part2, F>> f);
+}
diff --git a/src/main/java/bjc/typeclasses/package-info.java b/src/main/java/bjc/typeclasses/package-info.java
new file mode 100644
index 0000000..86ea3c1
--- /dev/null
+++ b/src/main/java/bjc/typeclasses/package-info.java
@@ -0,0 +1,18 @@
+/* 
+ * 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.typeclasses;
\ No newline at end of file
diff --git a/src/main/java/bjc/typeclasses/todo b/src/main/java/bjc/typeclasses/todo
new file mode 100644
index 0000000..55dd77d
--- /dev/null
+++ b/src/main/java/bjc/typeclasses/todo
@@ -0,0 +1,126 @@
+https://bartoszmilewski.com/2014/01/14/functors-are-containers/
+	Note that I've not quite ironed out the whole deal w/ BiContainer yet, and type classes which take two parameters
+
+For lenses, name the class Iso as Mirror instead, to keep with the theme
+
+A profunctor value of the type p a b could then be considered a container of bs that are keyed by elements of type a.
+
+class (Profunctor p) => TamModule (ten :: * -> * -> *) p where
+  leftAction  :: p a b -> p (c `ten` a) (c `ten` b)
+  rightAction :: p a b -> p (a `ten` c) (b `ten` c)
+
+type TamOptic ten s t a b 
+    = forall p. TamModule ten p => p a b -> p s t
+data Optic ten s t a b 
+    = forall c. Optic (s -> c `ten` a) (c `ten` b -> t)
+
+type TamProd p = TamModule (,) p
+type TamSum p = TamModule Either p
+
+data Pastro p a b where
+  Pastro :: ((y, z) -> b) -> p x y -> (a -> (x, z)) 
+            -> Pastro p a b
+data Copastro p a b where
+  Copastro :: (Either y z -> b) -> p x y -> (a -> Either x z) 
+            -> Copastro p a b
+// https://bartoszmilewski.com/2017/07/07/profunctor-optics-the-categorical-view/
+
+https://r6research.livejournal.com/28338.html?utm_source=3userpost - A new case for the pointed functor class
+https://r6research.livejournal.com/28050.html - Grate: A new kind of Optic
+https://r6research.livejournal.com/27476.html - Profunctor hierarchy for objects
+
+class Functor c => Naperian c where
+  zipFWith :: Functor f => (f a -> b) -> f (c a) -> (c b)
+
+class (Traversable v, Naperian v) => FiniteVector v where
+  naperianTraverse :: (Functor f, Applicative g) => (f a -> g b) -> f (v a) -> g (v b)
+
+-- A simple example to get people started.
+instance FiniteVector Triple where
+  naperianTraverse h fv = Triple <$> h (one <$> fv) <*> h (two <$> fv) <*> h (three <$> fv)
+   where
+    one (Triple x y z) = x
+    two (Triple x y z) = y
+    three (Triple x y z) = z
+vectorSize :: FiniteVector v => Proxy (Constant () (v a)) -> Integer
+vectorSize p = getSum . getConstant $ naperianTraverse (const (Constant (Sum 1)) (Constant () `asProxyTypeOf` p)
+class Profunctor p => Power p where
+  waddle :: FiniteVector v => p a b -> p (v a) (v b)
+type FiniteGrate s t a b = Power p => p a b -> p s t
+
+type Lens' s a = forall f. Functor f => (a -> f a) -> s -> f s
+
+// Create lens for a Hours/Minutes/Seconds time type, which does the right thing
+
+data SLens α γ β = SLens {putR :: (α, γ) → (β , γ), putL :: (β , γ) → (α, γ), missing :: γ }
+
+(;) :: (SLens α σ1 β ) → (SLens β σ2 γ) → (SLens α (σ1,σ2) γ)
+l1 ; l2 = SLens putR putL (l1.missing, l2.missing)
+	 where putR (a, (s1, s2)) =
+	 	 let (b, s′1) = putR (a, s1)
+	 		 (c, s′2) = putR (b, s2)
+		in (c, (s′1, s′2))
+	putL (c, (s1, s2)) =
+	   	let (b, s′2) = putL (c, s2)
+			(a, s′1) = putL (b, s1)
+		in (a, (s′1, s′2))
+idLensS :: SLens X () X
+idLensS = SLens id id ()
+
+type StateT σ τ α = σ → τ (α, σ)
+instance Monad τ ⇒ Monad (StateT σ τ ) where
+	return a = λs. return (a, s)
+	m >>= k = λs. do {(a, s′) ← m s; k a s′ 
+
+get :: Monad τ ⇒ StateT σ τ σ
+get = λs. return (s, s)
+set :: Monad τ ⇒ σ → StateT σ τ ()
+set s′ = λs. return ((), s′)
+
+lift :: Monad τ ⇒ τ α → StateT σ τ α
+lift m = λs. do {a ← m; return (a, s)} 
+
+gets :: Monad τ ⇒ (σ → α) → StateT σ τ α
+gets f = do {s ← get; return (f s)}
+eval :: Monad τ ⇒ StateT σ τ α → σ → τ α
+eval m s = do {(a, s′) ← m s; return a }
+exec :: Monad τ ⇒ StateT σ τ α → σ → τ σ
+exec m s = do {(a, s′) ← m s; return s′ } 
+
+data Codec g p x a = Codec { get :: g a, put :: x -> p a }
+instance (Functor g, Functor p) => Profunctor (Codec g p)
+instance (Monad g, Monad p) => Monad (Codec g p x)
+
+http://oleg.fi/gists/posts/2017-03-20-affine-traversal.html
+
+data Kiosk a b s t = Kiosk (s -> Either t a) (s -> b -> t)
+sellKiosk :: Kiosk a b a b
+sellKiosk = Kiosk Right (\_ -> id)
+instance Profunctor (Kiosk u v) where
+    dimap f g (Kiosk getter setter) = Kiosk
+        (\a -> first g $ getter (f a))
+        (\a v -> g (setter (f a) v))
+instance Strong (Kiosk u v) where
+    first' (Kiosk getter setter) = Kiosk
+        (\(a, c) -> first (,c) $ getter a)
+        (\(a, c) v -> (setter a v, c))
+instance Choice (Kiosk u v) where
+    right' (Kiosk getter setter) = Kiosk
+        (\eca -> assoc (second getter eca))
+        (\eca v -> second (`setter` v) eca)
+      where
+        assoc :: Either a (Either b c) -> Either (Either a b) c
+        assoc (Left a)          = Left (Left a)
+        assoc (Right (Left b))  = Left (Right b)
+        assoc (Right (Right c)) = Right c
+
+newtype Kiask a b t = Kiask { runKiask :: (Either t a, b -> t) }
+sellKiask :: a -> Kiask a b b
+sellKiask a = Kiask (Right a, id)
+instance Functor (Kiask a b) where
+    fmap f (Kiask (Left t, g)) = Kiask (Left (f t), f . g)
+    fmap f (Kiask (Right a, g)) = Kiask (Right a, f . g)
+instance Pointed (Kiask a b) where
+    point x = Kiask (Left x, const x)
+    
+http://oleg.fi/gists/posts/2021-01-08-indexed-optics-dilemma.html
\ No newline at end of file
diff --git a/src/test/java/bjc/test/functypes/optics/LensesTest.java b/src/test/java/bjc/test/functypes/optics/LensesTest.java
index ff13a42..c431c2f 100644
--- a/src/test/java/bjc/test/functypes/optics/LensesTest.java
+++ b/src/test/java/bjc/test/functypes/optics/LensesTest.java
@@ -5,7 +5,7 @@ import static org.junit.Assert.*;
 import org.junit.Test;
 
 import bjc.data.Holder;
-import bjc.functypes.optics.Lenses;
+import bjc.optics.Lenses;
 
 public class LensesTest {