diff --git a/CHANGELOG.md b/CHANGELOG.md
index 60491f794..405f7c8f0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,52 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## [Unreleased]
 ### Changed
+- ***Breaking Change***: `Sequence` now has two more type parameters to aid in inference
+- ***Breaking Change***: `Traversable#traverse` now has three more type parameters to aid in inference
+- ***Breaking Change***: `Monad#zip` now forces `m a -> b` before `m a` in default `Applicative#zip` implementation; this is only breaking for types that are sensitive to computation order (the resulting values are the same)
+- ***Breaking Change***: `TypeSafeKey` is now dually parametric (single parameter analog is preserved in `TypeSafeKey.Simple`)
+- `Bifunctor` is now a `BoundedBifunctor` where both parameter upper bounds are `Object`
+- `Peek2` now accepts the more general `BoundedBifunctor`
+- `Identity`, `Compose`, and `Const` functors all have better `toString` implementations
+- `Into3-8` now supports functions with parameter variance
+- `HListLens#tail` is now covariant in `Tail` parameter
+- More functions now automatically deforest nested calls (`concat` `cons`, `cycle`, `distinct`, `drop`, `dropwhile`, `filter`, `map`, `reverse`, `snoc`, `take`, `takewhile`, `tail`)
+- `Flatten` calls `Iterator#hasNext` less aggressively, allowing for better laziness
+- `Lens` subtypes `LensLike`
+- `View`/`Set`/`Over` now only require `LensLike`
+- `HMap#keys` now returns a `Set`
+- `HMap#values` now returns a `Collection`
+- `Unfoldr` is now lazier, deferring all computations until `hasNext/next` calls
+- `Present` is now a singleton
+
+### Added
+- `BoundedBifunctor`, a `Bifunctor` super type that offers upper bounds for both parameters
+- `Try`, a `Monad` representing an expression-like analog of `try/catch/finally`
+- `CheckedRunnable`, the `Runnable` counterpart to `CheckedSupplier` that can throw checked exceptions
+- `Unit`, the lambda analog to `Void`, except actually inhabited by a singleton instance 
+- `Kleisli`, the abstract representation of a `Kleisli` arrow (`Monad#flatMap`) as an `Fn1` 
+- `These`, a `CoProduct3` of `A`, `B`, or `Tuple2<A,B>`
+- `Span`, for splitting an `Iterable` into contiguous elements matching a predicate
+- `MagnetizeBy` and `Magnetize`, for grouping elements by pairwise predicate tests
+- `Both`, for dually applying two functions and producing a `Tuple2` of their results
+- `Lens#both`, for dually focusing with two lenses at once
+- `IfThenElse`, an expression form for `if` statements
+- `CheckedRunnable` and `CheckedSupplier` conversion and convenience methods
+- `LensLike`, common capabilities that make a type usable as if it were a `Lens`
+- `Iso`, isomorphisms between two types (invertible functions that are also lenses)
+- `Exchange`, a `Profunctor` that can extract the morphisms from an `Iso`
+- `HMapLens`, lenses focusing on `HMap`
+- `MapLens#mappingValues(Iso)`, a lawful lens that maps the values of a `j.u.Map`
+- `Under`, the inverse of `Over` for `Iso`
+- `TypeSafeKey` is an `Iso` and supports mapping
+- `TypeSafeKey.Simple`, the single parameter version of `TypeSafeKey`
+- `Either#trying` overloads that accept `CheckedRunnable`
+
+### Deprecated
+- `MapLens#mappingValues(Function)` is now deprecated in favor of the overload that takes an <code>Iso</code>
+
+## [2.1.1] - 2018-01-16
+### Changed
 - ***Breaking Change***: Moved `Trampoline` and `RecursiveResult` to better package
 
 ## [2.1.0] - 2018-01-14
@@ -254,7 +300,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `Monadic/Dyadic/TriadicFunction`, `Predicate`, `Tuple2`, `Tuple3`
 - `Functor`, `BiFunctor`, `ProFunctor` 
 
-[Unreleased]: https://github.com/palatable/lambda/compare/lambda-2.1.0...HEAD
+[Unreleased]: https://github.com/palatable/lambda/compare/lambda-2.1.1...HEAD
+[2.1.1]: https://github.com/palatable/lambda/compare/lambda-2.1.0...lambda-2.1.1
 [2.1.0]: https://github.com/palatable/lambda/compare/lambda-2.0.0...lambda-2.1.0
 [2.0.0]: https://github.com/palatable/lambda/compare/lambda-1.6.3...lambda-2.0.0
 [1.6.3]: https://github.com/palatable/lambda/compare/lambda-1.6.2...lambda-1.6.3
diff --git a/README.md b/README.md
index 4ff8f81e0..dcfe6df73 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 [![Build Status](https://img.shields.io/travis/palatable/lambda/master.svg)](https://travis-ci.org/palatable/lambda)
 [![Lambda](https://img.shields.io/maven-central/v/com.jnape.palatable/lambda.svg)](http://search.maven.org/#search%7Cga%7C1%7Ccom.jnape.palatable.lambda)
 
-Functional patterns for Java 8
+Functional patterns for Java
 
 #### Table of Contents
 
@@ -57,14 +57,14 @@ Add the following dependency to your:
 <dependency>
     <groupId>com.jnape.palatable</groupId>
     <artifactId>lambda</artifactId>
-    <version>2.1.0</version>
+    <version>2.1.1</version>
 </dependency>
 ```
 
 `build.gradle` ([Gradle](https://docs.gradle.org/current/userguide/dependency_management.html)):
 
 ```gradle
-compile group: 'com.jnape.palatable', name: 'lambda', version: '2.1.0'
+compile group: 'com.jnape.palatable', name: 'lambda', version: '2.1.1'
 ```
 
 <a name="examples">Examples</a>
@@ -366,11 +366,11 @@ public static void main(String[] args) {
 }
 ```
 
-In the previous example, if any of `parseId`, `lookupById`, or `getOccupation` fail, no further `flatMap` computations can succeed, so the result short-circuits to the first `left` value that is returned. This is completely predictable from the type signature of `Monad` and `Either`: `Either<L, R>` is a `Monad<R>`, so the single arity `flatMap` can have nothing to map in the case where there is no `R` value. With experience, it generally becomes quickly clear what the logical behavior of `flatMap` *must* be given the type signatures.  
+In the previous example, if any of `parseId`, `lookupById`, or `getOccupation` fail, no further `flatMap` computations can succeed, so the result short-circuits to the first `left` value that is returned. This is completely predictable from the type signature of `Monad` and `Either`: `Either<L, R>` is a `Monad<R>`, so the single arity `flatMap` can have nothing to map in the case where there is no `R` value. With experience, it generally becomes quickly clear what the logical behavior of `flatMap` *must* be given the type signatures.
 
 That's it. Monads are neither [elephants](http://james-iry.blogspot.com/2007/09/monads-are-elephants-part-1.html) nor are they [burritos](https://blog.plover.com/prog/burritos.html); they're simply types that support a) the ability to lift a value into them, and b) a chaining function `flatMap :: (a -> f b) -> f a -> f b` that can potentially return different instances of the same monad. If a type can do those two things (and obeys [the laws](https://wiki.haskell.org/Monad_laws)), it is a monad.
 
-Further, if a type is a monad, it is necessarily an `Applicative`, which makes it necessariliy a `Functor`, so *lambda* enforces this tautology via a hierarchical constraint.    
+Further, if a type is a monad, it is necessarily an `Applicative`, which makes it necessarily a `Functor`, so *lambda* enforces this tautology via a hierarchical constraint.
 
 ### <a name="traversables">Traversables</a>
 
@@ -504,7 +504,7 @@ Optional.of(1).map(nullResultFn); // Optional.empty()
 Maybe.just(1).fmap(nullResultFn); // throws NullPointerException
 
 Maybe.just(1).flatMap(nullResultFn.andThen(Maybe::maybe)); // Nothing
-```  
+```
 
 ### <a name="hlists">Heterogeneous Lists (HLists)</a>
 
@@ -601,7 +601,7 @@ HMap hmap = HMap.hMap(stringKey, "string value",
 Optional<String> stringValue = hmap.get(stringKey); // Optional["string value"]
 Optional<Integer> intValue = hmap.get(intKey); // Optional[1]
 Optional<Integer> anotherIntValue = hmap.get(anotherIntKey); // Optional.empty
-```    
+```
 
 ### <a name="coproducts">CoProducts</a>
 
diff --git a/pom.xml b/pom.xml
index 94b3a6847..d990937e0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,7 +9,7 @@
     </parent>
 
     <artifactId>lambda</artifactId>
-    <version>2.1.1</version>
+    <version>3.0.0</version>
     <packaging>jar</packaging>
 
     <name>Lambda</name>
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
index b9fe4fe9b..0fbcf2dd5 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/Either.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
@@ -4,6 +4,7 @@
 import com.jnape.palatable.lambda.functions.builtin.fn2.Peek;
 import com.jnape.palatable.lambda.functions.builtin.fn2.Peek2;
 import com.jnape.palatable.lambda.functions.specialized.checked.CheckedFn1;
+import com.jnape.palatable.lambda.functions.specialized.checked.CheckedRunnable;
 import com.jnape.palatable.lambda.functions.specialized.checked.CheckedSupplier;
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Bifunctor;
@@ -21,9 +22,9 @@
 import static java.util.Arrays.asList;
 
 /**
- * The binary tagged union. General semantics tend to connote "success" values via the right value and "failure" values
- * via the left values. <code>Either</code>s are both <code>Functor</code>s over their right value and
- * <code>Bifunctor</code>s over both values.
+ * The binary tagged union, implemented as a specialized {@link CoProduct2}. General semantics tend to connote "success"
+ * values via the right value and "failure" values via the left values. {@link Either}s are both {@link Monad}s and
+ * {@link Traversable}s over their right value and are {@link Bifunctor}s over both values.
  *
  * @param <L> The left parameter type
  * @param <R> The right parameter type
@@ -224,31 +225,31 @@ public final <L2, R2> Either<L2, R2> biMap(Function<? super L, ? extends L2> lef
     }
 
     @Override
-    public <R2> Either<L, R2> pure(R2 r2) {
+    public final <R2> Either<L, R2> pure(R2 r2) {
         return right(r2);
     }
 
     @Override
-    public <R2> Either<L, R2> zip(Applicative<Function<? super R, ? extends R2>, Either<L, ?>> appFn) {
+    public final <R2> Either<L, R2> zip(Applicative<Function<? super R, ? extends R2>, Either<L, ?>> appFn) {
         return appFn.<Either<L, Function<? super R, ? extends R2>>>coerce().flatMap(this::biMapR);
     }
 
     @Override
-    public <R2> Either<L, R2> discardL(Applicative<R2, Either<L, ?>> appB) {
+    public final <R2> Either<L, R2> discardL(Applicative<R2, Either<L, ?>> appB) {
         return Monad.super.discardL(appB).coerce();
     }
 
     @Override
-    public <R2> Either<L, R> discardR(Applicative<R2, Either<L, ?>> appB) {
+    public final <R2> Either<L, R> discardR(Applicative<R2, Either<L, ?>> appB) {
         return Monad.super.discardR(appB).coerce();
     }
 
     @Override
-    public <R2, App extends Applicative> Applicative<Either<L, R2>, App> traverse(
-            Function<? super R, ? extends Applicative<R2, App>> fn,
-            Function<? super Traversable<R2, Either<L, ?>>, ? extends Applicative<? extends Traversable<R2, Either<L, ?>>, App>> pure) {
-        return match(l -> pure.apply(left(l)).fmap(x -> (Either<L, R2>) x),
-                     r -> fn.apply(r).fmap(Either::right));
+    @SuppressWarnings("unchecked")
+    public final <R2, App extends Applicative, TravB extends Traversable<R2, Either<L, ?>>, AppB extends Applicative<R2, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super R, ? extends AppB> fn,
+            Function<? super TravB, ? extends AppTrav> pure) {
+        return (AppTrav) match(l -> pure.apply((TravB) left(l)), r -> fn.apply(r).fmap(Either::right));
     }
 
     /**
@@ -257,7 +258,7 @@ public <R2, App extends Applicative> Applicative<Either<L, R2>, App> traverse(
      *
      * @return Maybe the right value
      */
-    public Maybe<R> toMaybe() {
+    public final Maybe<R> toMaybe() {
         return projectB();
     }
 
@@ -287,14 +288,9 @@ public static <L, R> Either<L, R> fromMaybe(Maybe<R> maybe, Supplier<L> leftFn)
      * @param <R>      the right parameter type
      * @return the supplier result as a right value, or leftFn's mapping result as a left value
      */
-    @SuppressWarnings("unchecked")
     public static <E extends Exception, L, R> Either<L, R> trying(CheckedSupplier<E, ? extends R> supplier,
                                                                   Function<? super E, ? extends L> leftFn) {
-        try {
-            return right(supplier.get());
-        } catch (Exception e) {
-            return left(leftFn.apply((E) e));
-        }
+        return Try.<E, R>trying(supplier::get).toEither(leftFn);
     }
 
     /**
@@ -310,6 +306,33 @@ public static <E extends Exception, R> Either<E, R> trying(CheckedSupplier<E, R>
         return trying(supplier, id());
     }
 
+    /**
+     * Attempt to execute the {@link CheckedRunnable}, returning {@link Unit} in a right value. If the runnable throws
+     * an exception, apply <code>leftFn</code> to it, wrap it in a left value, and return it.
+     *
+     * @param runnable the runnable
+     * @param leftFn   a function mapping E to L
+     * @param <E>      the most contravariant exception that the runnable might throw
+     * @param <L>      the left parameter type
+     * @return {@link Unit} as a right value, or leftFn's mapping result as a left value
+     */
+    public static <E extends Exception, L> Either<L, Unit> trying(CheckedRunnable<E> runnable,
+                                                                  Function<? super E, ? extends L> leftFn) {
+        return Try.trying(runnable).toEither(leftFn);
+    }
+
+    /**
+     * Attempt to execute the {@link CheckedRunnable}, returning {@link Unit} in a right value. If the runnable throws
+     * exception, wrap it in a left value and return it.
+     *
+     * @param runnable the runnable
+     * @param <E>      the left parameter type (the most contravariant exception that runnable might throw)
+     * @return {@link Unit} as a right value, or a left value of the thrown exception
+     */
+    public static <E extends Exception> Either<E, Unit> trying(CheckedRunnable<E> runnable) {
+        return trying(runnable, id());
+    }
+
     /**
      * Static factory method for creating a left value.
      *
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java b/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java
index 9bfc7eed0..93a700061 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java
@@ -14,8 +14,6 @@
 import java.util.function.Supplier;
 
 import static com.jnape.palatable.lambda.adt.Either.left;
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
  * The optional type, representing a potentially absent value. This is lambda's analog of {@link Optional}, supporting
@@ -134,11 +132,6 @@ public final <B> Maybe<A> discardR(Applicative<B, Maybe> appB) {
     @Override
     public abstract <B> Maybe<B> flatMap(Function<? super A, ? extends Monad<B, Maybe>> f);
 
-    @Override
-    public abstract <B, App extends Applicative> Applicative<Maybe<B>, App> traverse(
-            Function<? super A, ? extends Applicative<B, App>> fn,
-            Function<? super Traversable<B, Maybe>, ? extends Applicative<? extends Traversable<B, Maybe>, App>> pure);
-
     /**
      * If this value is present, accept it by <code>consumer</code>; otherwise, do nothing.
      *
@@ -158,7 +151,7 @@ public final Maybe<A> peek(Consumer<A> consumer) {
      * @return "Just" the right value, or nothing
      */
     public static <A> Maybe<A> fromEither(Either<?, A> either) {
-        return either.match(constantly(nothing()), Maybe::just);
+        return either.toMaybe();
     }
 
     /**
@@ -169,7 +162,7 @@ public static <A> Maybe<A> fromEither(Either<?, A> either) {
      * @return the equivalent Maybe instance
      */
     public static <A> Maybe<A> fromOptional(Optional<? extends A> optional) {
-        return optional.<A>map(id()).map(Maybe::just).orElse(Maybe.nothing());
+        return optional.map(Maybe::<A>just).orElse(Maybe.nothing());
     }
 
     /**
@@ -223,10 +216,11 @@ public <B> Maybe<B> flatMap(Function<? super A, ? extends Monad<B, Maybe>> f) {
         }
 
         @Override
-        public <B, App extends Applicative> Applicative<Maybe<B>, App> traverse(
-                Function<? super A, ? extends Applicative<B, App>> fn,
-                Function<? super Traversable<B, Maybe>, ? extends Applicative<? extends Traversable<B, Maybe>, App>> pure) {
-            return fn.apply(a).fmap(Just::new);
+        @SuppressWarnings("unchecked")
+        public <B, App extends Applicative, TravB extends Traversable<B, Maybe>,
+                AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+                Function<? super A, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+            return fn.apply(a).fmap(Just::new).<TravB>fmap(Applicative::coerce).coerce();
         }
 
         @Override
@@ -259,10 +253,9 @@ public <B> Maybe<B> flatMap(Function<? super A, ? extends Monad<B, Maybe>> f) {
 
         @Override
         @SuppressWarnings("unchecked")
-        public <B, App extends Applicative> Applicative<Maybe<B>, App> traverse(
-                Function<? super A, ? extends Applicative<B, App>> fn,
-                Function<? super Traversable<B, Maybe>, ? extends Applicative<? extends Traversable<B, Maybe>, App>> pure) {
-            return (Applicative<Maybe<B>, App>) pure.apply(nothing());
+        public <B, App extends Applicative, TravB extends Traversable<B, Maybe>, AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+                Function<? super A, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+            return pure.apply((TravB) nothing());
         }
 
         @Override
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/These.java b/src/main/java/com/jnape/palatable/lambda/adt/These.java
new file mode 100644
index 000000000..f4ffc5846
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/adt/These.java
@@ -0,0 +1,240 @@
+package com.jnape.palatable.lambda.adt;
+
+import com.jnape.palatable.lambda.adt.coproduct.CoProduct2;
+import com.jnape.palatable.lambda.adt.coproduct.CoProduct3;
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.functor.Bifunctor;
+import com.jnape.palatable.lambda.monad.Monad;
+import com.jnape.palatable.lambda.traversable.Traversable;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Into.into;
+
+/**
+ * The coproduct of a coproduct (<code>{@link CoProduct2}&lt;A, B&gt;</code>) and its product (<code>{@link
+ * Tuple2}&lt;A, B&gt;</code>), represented as a <code>{@link CoProduct3}&lt;A, B, {@link Tuple2}&lt;A,
+ * B&gt;&gt;</code>.
+ *
+ * @param <A> the first possible type
+ * @param <B> the second possible type
+ */
+public abstract class These<A, B> implements CoProduct3<A, B, Tuple2<A, B>, These<A, B>>, Monad<B, These<A, ?>>, Bifunctor<A, B, These<?, ?>>, Traversable<B, These<A, ?>> {
+
+    private These() {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public final <C, D> These<C, D> biMap(Function<? super A, ? extends C> lFn,
+                                          Function<? super B, ? extends D> rFn) {
+        return match(a -> a(lFn.apply(a)), b -> b(rFn.apply(b)), into((a, b) -> both(lFn.apply(a), rFn.apply(b))));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public final <C> These<A, C> flatMap(Function<? super B, ? extends Monad<C, These<A, ?>>> f) {
+        return match(These::a, b -> f.apply(b).coerce(), into((a, b) -> f.apply(b).<These<A, C>>coerce().biMapL(constantly(a))));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public final <C> These<A, C> pure(C c) {
+        return match(a -> both(a, c), b -> b(c), into((a, b) -> both(a, c)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <C, App extends Applicative, TravB extends Traversable<C, These<A, ?>>, AppB extends Applicative<C, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super B, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) a(a)),
+                     b -> fn.apply(b).fmap(this::pure).<TravB>fmap(Applicative::coerce).coerce(),
+                     into((a, b) -> fn.apply(b).fmap(c -> both(a, c)).<TravB>fmap(Applicative::coerce).coerce()));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    public final <Z> These<Z, B> biMapL(Function<? super A, ? extends Z> fn) {
+        return (These<Z, B>) Bifunctor.super.biMapL(fn);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    public final <C> These<A, C> biMapR(Function<? super B, ? extends C> fn) {
+        return (These<A, C>) Bifunctor.super.biMapR(fn);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public final <C> These<A, C> fmap(Function<? super B, ? extends C> fn) {
+        return Monad.super.<C>fmap(fn).coerce();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public final <C> These<A, C> zip(Applicative<Function<? super B, ? extends C>, These<A, ?>> appFn) {
+        return Monad.super.zip(appFn).coerce();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public final <C> These<A, C> discardL(Applicative<C, These<A, ?>> appB) {
+        return Monad.super.discardL(appB).coerce();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public final <C> These<A, B> discardR(Applicative<C, These<A, ?>> appB) {
+        return Monad.super.discardR(appB).coerce();
+    }
+
+    /**
+     * Static factory method for wrapping a value of type <code>A</code> in a {@link These}.
+     *
+     * @param a   the value
+     * @param <A> the first possible type
+     * @param <B> the second possible type
+     * @return the wrapped value as a <code>{@link These}&lt;A,B&gt;</code>
+     */
+    public static <A, B> These<A, B> a(A a) {
+        return new _A<>(a);
+    }
+
+    /**
+     * Static factory method for wrapping a value of type <code>B</code> in a {@link These}.
+     *
+     * @param b   the value
+     * @param <A> the first possible type
+     * @param <B> the second possible type
+     * @return the wrapped value as a <code>{@link These}&lt;A,B&gt;</code>
+     */
+    public static <A, B> These<A, B> b(B b) {
+        return new _B<>(b);
+    }
+
+    /**
+     * Static factory method for wrapping a value of type <code>A</code> and a value of type <code>B</code> in a {@link
+     * These}.
+     *
+     * @param a   the first value
+     * @param b   the second value
+     * @param <A> the first possible type
+     * @param <B> the second possible type
+     * @return the wrapped values as a <code>{@link These}&lt;A,B&gt;</code>
+     */
+    public static <A, B> These<A, B> both(A a, B b) {
+        return new Both<>(tuple(a, b));
+    }
+
+    private static final class _A<A, B> extends These<A, B> {
+
+        private final A a;
+
+        private _A(A a) {
+            this.a = a;
+        }
+
+        @Override
+        public <R> R match(Function<? super A, ? extends R> aFn, Function<? super B, ? extends R> bFn,
+                           Function<? super Tuple2<A, B>, ? extends R> cFn) {
+            return aFn.apply(a);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            return other instanceof These._A && Objects.equals(a, ((_A) other).a);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(a);
+        }
+
+        @Override
+        public String toString() {
+            return "These{a=" + a + '}';
+        }
+    }
+
+    private static final class _B<A, B> extends These<A, B> {
+        private final B b;
+
+        private _B(B b) {
+            this.b = b;
+        }
+
+        @Override
+        public <R> R match(Function<? super A, ? extends R> aFn, Function<? super B, ? extends R> bFn,
+                           Function<? super Tuple2<A, B>, ? extends R> cFn) {
+            return bFn.apply(b);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            return other instanceof These._B && Objects.equals(b, ((_B) other).b);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(b);
+        }
+
+        @Override
+        public String toString() {
+            return "These{b=" + b + '}';
+        }
+    }
+
+    private static final class Both<A, B> extends These<A, B> {
+        private final Tuple2<A, B> both;
+
+        private Both(Tuple2<A, B> tuple) {
+            this.both = tuple;
+        }
+
+        @Override
+        public <R> R match(Function<? super A, ? extends R> aFn, Function<? super B, ? extends R> bFn,
+                           Function<? super Tuple2<A, B>, ? extends R> cFn) {
+            return cFn.apply(both);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            return other instanceof Both && Objects.equals(both, ((Both) other).both);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(both);
+        }
+
+        @Override
+        public String toString() {
+            return "These{both=" + both + '}';
+        }
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Try.java b/src/main/java/com/jnape/palatable/lambda/adt/Try.java
new file mode 100644
index 000000000..0a2169f09
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/adt/Try.java
@@ -0,0 +1,318 @@
+package com.jnape.palatable.lambda.adt;
+
+import com.jnape.palatable.lambda.adt.coproduct.CoProduct2;
+import com.jnape.palatable.lambda.functions.specialized.checked.CheckedRunnable;
+import com.jnape.palatable.lambda.functions.specialized.checked.CheckedSupplier;
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.functor.BoundedBifunctor;
+import com.jnape.palatable.lambda.monad.Monad;
+import com.jnape.palatable.lambda.traversable.Traversable;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Peek2.peek2;
+
+/**
+ * A {@link Monad} of the evaluation outcome of an expression that might throw. Try/catch/finally semantics map to
+ * <code>trying</code>/<code>catching</code>/<code>ensuring</code>, respectively.
+ *
+ * @param <T> the {@link Throwable} type that may have been thrown by the expression
+ * @param <A> the possibly successful expression result
+ * @see Either
+ */
+public abstract class Try<T extends Throwable, A> implements Monad<A, Try<T, ?>>, Traversable<A, Try<T, ?>>, BoundedBifunctor<T, A, Throwable, Object, Try<?, ?>>, CoProduct2<T, A, Try<T, A>> {
+
+    private Try() {
+    }
+
+    /**
+     * Catch any instance of <code>throwableType</code> and map it to a success value.
+     *
+     * @param throwableType the {@link Throwable} (sub)type to be caught
+     * @param recoveryFn    the function mapping the {@link Throwable} to the result
+     * @param <S>           the {@link Throwable} (sub)type
+     * @return a new {@link Try} instance around either the original successful result or the mapped result
+     */
+    @SuppressWarnings("unchecked")
+    public final <S extends T> Try<T, A> catching(Class<S> throwableType, Function<? super S, ? extends A> recoveryFn) {
+        return catching(throwableType::isInstance, t -> recoveryFn.apply((S) t));
+    }
+
+    /**
+     * Catch any thrown <code>T</code> satisfying <code>predicate</code> and map it to a success value.
+     *
+     * @param predicate  the predicate
+     * @param recoveryFn the function mapping the {@link Throwable} to the result
+     * @return a new {@link Try} instance around either the original successful result or the mapped result
+     */
+    public final Try<T, A> catching(Function<? super T, Boolean> predicate,
+                                    Function<? super T, ? extends A> recoveryFn) {
+        return match(t -> predicate.apply(t) ? success(recoveryFn.apply(t)) : failure(t), Try::success);
+    }
+
+    /**
+     * Run the provided runnable regardless of whether this is a success or a failure (the {@link Try} analog to
+     * <code>finally</code>.
+     * <p>
+     * If the runnable runs successfully, the result is preserved as is. If the runnable itself throws, and the result
+     * was a success, the result becomes a failure over the newly-thrown {@link Throwable}. If the result was a failure
+     * over some {@link Throwable} <code>t1</code>, and the runnable throws a new {@link Throwable} <code>t2</code>, the
+     * result is a failure over <code>t1</code> with <code>t2</code> added to <code>t1</code> as a suppressed exception.
+     *
+     * @param runnable the runnable block of code to execute
+     * @return the same {@link Try} instance if runnable completes successfully; otherwise, a {@link Try} conforming to
+     * rules above
+     */
+    public final Try<T, A> ensuring(CheckedRunnable<T> runnable) {
+        return match(t -> peek2(t::addSuppressed, __ -> {}, trying(runnable))
+                             .biMapL(constantly(t))
+                             .flatMap(constantly(failure(t))),
+                     a -> trying(runnable).fmap(constantly(a)));
+    }
+
+    /**
+     * If this is a success, return the wrapped value. Otherwise, apply the {@link Throwable} to <code>fn</code> and
+     * return the result.
+     *
+     * @param fn the function mapping the potential {@link Throwable} <code>T</code> to <code>A</code>
+     * @return a success value
+     */
+    public final A recover(Function<? super T, ? extends A> fn) {
+        return match(fn, id());
+    }
+
+    /**
+     * If this is a failure, return the wrapped value. Otherwise, apply the success value to <code>fn</code> and return
+     * the result.
+     *
+     * @param fn the function mapping the potential <code>A</code> to <code>T</code>
+     * @return a failure value
+     */
+    public final T forfeit(Function<? super A, ? extends T> fn) {
+        return match(id(), fn);
+    }
+
+    /**
+     * If this is a success value, return it. Otherwise, rethrow the captured failure.
+     *
+     * @return possibly the success value
+     * @throws T the possible failure
+     */
+    public abstract A orThrow() throws T;
+
+    /**
+     * If this is a success, wrap the value in a {@link Maybe#just} and return it. Otherwise, return {@link
+     * Maybe#nothing()}.
+     *
+     * @return {@link Maybe} the success value
+     */
+    public final Maybe<A> toMaybe() {
+        return match(__ -> nothing(), Maybe::just);
+    }
+
+    /**
+     * If this is a success, wrap the value in a {@link Either#right} and return it. Otherwise, return the {@link
+     * Throwable} in an {@link Either#left}.
+     *
+     * @return {@link Either} the success value or the {@link Throwable}
+     */
+    public final Either<T, A> toEither() {
+        return toEither(id());
+    }
+
+    /**
+     * If this is a success, wrap the value in a {@link Either#right} and return it. Otherwise, apply the mapping
+     * function to the failure {@link Throwable}, re-wrap it in an {@link Either#left}, and return it.
+     *
+     * @param fn  the mapping function
+     * @param <L> the {@link Either} left parameter type
+     * @return {@link Either} the success value or the mapped left value
+     */
+    public final <L> Either<L, A> toEither(Function<? super T, ? extends L> fn) {
+        return match(fn.andThen(Either::left), Either::right);
+    }
+
+    @Override
+    public <B> Try<T, B> fmap(Function<? super A, ? extends B> fn) {
+        return Monad.super.<B>fmap(fn).coerce();
+    }
+
+    @Override
+    public <B> Try<T, B> flatMap(Function<? super A, ? extends Monad<B, Try<T, ?>>> f) {
+        return match(Try::failure, a -> f.apply(a).coerce());
+    }
+
+    @Override
+    public <B> Try<T, B> pure(B b) {
+        return success(b);
+    }
+
+    @Override
+    public <B> Try<T, B> zip(Applicative<Function<? super A, ? extends B>, Try<T, ?>> appFn) {
+        return Monad.super.zip(appFn).coerce();
+    }
+
+    @Override
+    public <B> Try<T, B> discardL(Applicative<B, Try<T, ?>> appB) {
+        return Monad.super.discardL(appB).coerce();
+    }
+
+    @Override
+    public <B> Try<T, A> discardR(Applicative<B, Try<T, ?>> appB) {
+        return Monad.super.discardR(appB).coerce();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <B, App extends Applicative, TravB extends Traversable<B, Try<T, ?>>, AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super A, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(t -> pure.apply((TravB) failure(t)),
+                     a -> fn.apply(a).fmap(Try::success).<TravB>fmap(Applicative::coerce).coerce());
+    }
+
+    @Override
+    public <U extends Throwable, D> Try<U, D> biMap(Function<? super T, ? extends U> lFn,
+                                                    Function<? super A, ? extends D> rFn) {
+        return match(t -> failure(lFn.apply(t)), a -> success(rFn.apply(a)));
+    }
+
+    @Override
+    public <U extends Throwable> Try<U, A> biMapL(Function<? super T, ? extends U> fn) {
+        return (Try<U, A>) BoundedBifunctor.super.<U>biMapL(fn);
+    }
+
+    @Override
+    public <B> Try<T, B> biMapR(Function<? super A, ? extends B> fn) {
+        return (Try<T, B>) BoundedBifunctor.super.<B>biMapR(fn);
+    }
+
+    /**
+     * Static factory method for creating a success value.
+     *
+     * @param a   the wrapped value
+     * @param <T> the failure parameter type
+     * @param <A> the success parameter type
+     * @return a success value of a
+     */
+    public static <T extends Throwable, A> Try<T, A> success(A a) {
+        return new Success<>(a);
+    }
+
+    /**
+     * Static factory method for creating a failure value.
+     *
+     * @param t   the wrapped {@link Throwable}
+     * @param <T> the failure parameter type
+     * @param <A> the success parameter type
+     * @return a failure value of t
+     */
+    public static <T extends Throwable, A> Try<T, A> failure(T t) {
+        return new Failure<>(t);
+    }
+
+    /**
+     * Execute <code>supplier</code>, returning a success <code>A</code> or a failure of the thrown {@link Throwable}.
+     *
+     * @param supplier the supplier
+     * @param <T>      the possible {@link Throwable} type
+     * @param <A>      the possible success type
+     * @return a new {@link Try} around either a successful A result or the thrown {@link Throwable}
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends Throwable, A> Try<T, A> trying(CheckedSupplier<T, A> supplier) {
+        try {
+            return success(supplier.get());
+        } catch (Throwable t) {
+            return failure((T) t);
+        }
+    }
+
+    /**
+     * Execute <code>runnable</code>, returning a success {@link Unit} or a failure of the thrown {@link Throwable}.
+     *
+     * @param runnable the runnable
+     * @param <T>      the possible {@link Throwable} type
+     * @return a new {@link Try} around either a successful {@link Unit} result or the thrown {@link Throwable}
+     */
+    public static <T extends Throwable> Try<T, Unit> trying(CheckedRunnable<T> runnable) {
+        return trying(() -> {
+            runnable.run();
+            return UNIT;
+        });
+    }
+
+    private static final class Failure<T extends Throwable, A> extends Try<T, A> {
+        private final T t;
+
+        private Failure(T t) {
+            this.t = t;
+        }
+
+        @Override
+        public A orThrow() throws T {
+            throw t;
+        }
+
+        @Override
+        public <R> R match(Function<? super T, ? extends R> aFn, Function<? super A, ? extends R> bFn) {
+            return aFn.apply(t);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            return other instanceof Failure && Objects.equals(t, ((Failure) other).t);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(t);
+        }
+
+        @Override
+        public String toString() {
+            return "Failure{" +
+                    "t=" + t +
+                    '}';
+        }
+    }
+
+    private static final class Success<T extends Throwable, A> extends Try<T, A> {
+        private final A a;
+
+        private Success(A a) {
+            this.a = a;
+        }
+
+        @Override
+        public A orThrow() throws T {
+            return a;
+        }
+
+        @Override
+        public <R> R match(Function<? super T, ? extends R> aFn, Function<? super A, ? extends R> bFn) {
+            return bFn.apply(a);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            return other instanceof Success && Objects.equals(a, ((Success) other).a);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(a);
+        }
+
+        @Override
+        public String toString() {
+            return "Success{" +
+                    "a=" + a +
+                    '}';
+        }
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Unit.java b/src/main/java/com/jnape/palatable/lambda/adt/Unit.java
new file mode 100644
index 000000000..0373cdac7
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/adt/Unit.java
@@ -0,0 +1,21 @@
+package com.jnape.palatable.lambda.adt;
+
+/**
+ * The empty return type. Unlike {@link Void}, this type is actually inhabited by a singleton instance that can be used,
+ * rather than having to resort to <code>null</code>.
+ */
+public final class Unit {
+
+    /**
+     * The singleton instance.
+     */
+    public static final Unit UNIT = new Unit();
+
+    private Unit() {
+    }
+
+    @Override
+    public String toString() {
+        return "Unit{}";
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice2.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice2.java
index f38f681cf..5276adb04 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice2.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice2.java
@@ -84,11 +84,11 @@ public final <C> Choice2<A, C> flatMap(Function<? super B, ? extends Monad<C, Ch
     }
 
     @Override
-    public <C, App extends Applicative> Applicative<Choice2<A, C>, App> traverse(
-            Function<? super B, ? extends Applicative<C, App>> fn,
-            Function<? super Traversable<C, Choice2<A, ?>>, ? extends Applicative<? extends Traversable<C, Choice2<A, ?>>, App>> pure) {
-        return match(a -> pure.apply(a(a)).fmap(x -> (Choice2<A, C>) x),
-                     b -> fn.apply(b).fmap(Choice2::b));
+    @SuppressWarnings("unchecked")
+    public <C, App extends Applicative, TravB extends Traversable<C, Choice2<A, ?>>, AppB extends Applicative<C, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super B, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) a(a)),
+                     b -> fn.apply(b).fmap(Choice2::b).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice3.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice3.java
index 4ef49ac33..8cc0abba5 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice3.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice3.java
@@ -88,12 +88,12 @@ public <D> Choice3<A, B, D> flatMap(Function<? super C, ? extends Monad<D, Choic
     }
 
     @Override
-    public <D, App extends Applicative> Applicative<Choice3<A, B, D>, App> traverse(
-            Function<? super C, ? extends Applicative<D, App>> fn,
-            Function<? super Traversable<D, Choice3<A, B, ?>>, ? extends Applicative<? extends Traversable<D, Choice3<A, B, ?>>, App>> pure) {
-        return match(a -> pure.apply(a(a)).fmap(x -> (Choice3<A, B, D>) x),
-                     b -> pure.apply(b(b)).fmap(x -> (Choice3<A, B, D>) x),
-                     c -> fn.apply(c).fmap(Choice3::c));
+    @SuppressWarnings("unchecked")
+    public <D, App extends Applicative, TravB extends Traversable<D, Choice3<A, B, ?>>, AppB extends Applicative<D, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super C, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) Choice3.<A, B, D>a(a)).coerce(),
+                     b -> pure.apply((TravB) Choice3.<A, B, D>b(b)).coerce(),
+                     c -> fn.apply(c).fmap(Choice3::c).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice4.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice4.java
index dc98c7231..9a604fa71 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice4.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice4.java
@@ -92,13 +92,13 @@ public <E> Choice4<A, B, C, E> flatMap(Function<? super D, ? extends Monad<E, Ch
     }
 
     @Override
-    public <E, App extends Applicative> Applicative<Choice4<A, B, C, E>, App> traverse(
-            Function<? super D, ? extends Applicative<E, App>> fn,
-            Function<? super Traversable<E, Choice4<A, B, C, ?>>, ? extends Applicative<? extends Traversable<E, Choice4<A, B, C, ?>>, App>> pure) {
-        return match(a -> pure.apply(a(a)).fmap(x -> (Choice4<A, B, C, E>) x),
-                     b -> pure.apply(b(b)).fmap(x -> (Choice4<A, B, C, E>) x),
-                     c -> pure.apply(c(c)).fmap(x -> (Choice4<A, B, C, E>) x),
-                     d -> fn.apply(d).fmap(Choice4::d));
+    @SuppressWarnings("unchecked")
+    public <E, App extends Applicative, TravB extends Traversable<E, Choice4<A, B, C, ?>>, AppB extends Applicative<E, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super D, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) Choice4.<A, B, C, E>a(a)).coerce(),
+                     b -> pure.apply((TravB) Choice4.<A, B, C, E>b(b)).coerce(),
+                     c -> pure.apply((TravB) Choice4.<A, B, C, E>c(c)),
+                     d -> fn.apply(d).fmap(Choice4::d).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice5.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice5.java
index f3d609dd4..758aa2a00 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice5.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice5.java
@@ -94,14 +94,14 @@ public <F> Choice5<A, B, C, D, F> flatMap(Function<? super E, ? extends Monad<F,
     }
 
     @Override
-    public <F, App extends Applicative> Applicative<Choice5<A, B, C, D, F>, App> traverse(
-            Function<? super E, ? extends Applicative<F, App>> fn,
-            Function<? super Traversable<F, Choice5<A, B, C, D, ?>>, ? extends Applicative<? extends Traversable<F, Choice5<A, B, C, D, ?>>, App>> pure) {
-        return match(a -> pure.apply(a(a)).fmap(x -> (Choice5<A, B, C, D, F>) x),
-                     b -> pure.apply(b(b)).fmap(x -> (Choice5<A, B, C, D, F>) x),
-                     c -> pure.apply(c(c)).fmap(x -> (Choice5<A, B, C, D, F>) x),
-                     d -> pure.apply(d(d)).fmap(x -> (Choice5<A, B, C, D, F>) x),
-                     e -> fn.apply(e).fmap(Choice5::e));
+    @SuppressWarnings("unchecked")
+    public <F, App extends Applicative, TravB extends Traversable<F, Choice5<A, B, C, D, ?>>, AppB extends Applicative<F, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super E, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) Choice5.<A, B, C, D, F>a(a)).coerce(),
+                     b -> pure.apply((TravB) Choice5.<A, B, C, D, F>b(b)).coerce(),
+                     c -> pure.apply((TravB) Choice5.<A, B, C, D, F>c(c)),
+                     d -> pure.apply((TravB) Choice5.<A, B, C, D, F>d(d)),
+                     e -> fn.apply(e).fmap(Choice5::e).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice6.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice6.java
index b351db250..9286e9abf 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice6.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice6.java
@@ -98,15 +98,15 @@ public <G> Choice6<A, B, C, D, E, G> flatMap(
     }
 
     @Override
-    public <G, App extends Applicative> Applicative<Choice6<A, B, C, D, E, G>, App> traverse(
-            Function<? super F, ? extends Applicative<G, App>> fn,
-            Function<? super Traversable<G, Choice6<A, B, C, D, E, ?>>, ? extends Applicative<? extends Traversable<G, Choice6<A, B, C, D, E, ?>>, App>> pure) {
-        return match(a -> pure.apply(a(a)).fmap(x -> (Choice6<A, B, C, D, E, G>) x),
-                     b -> pure.apply(b(b)).fmap(x -> (Choice6<A, B, C, D, E, G>) x),
-                     c -> pure.apply(c(c)).fmap(x -> (Choice6<A, B, C, D, E, G>) x),
-                     d -> pure.apply(d(d)).fmap(x -> (Choice6<A, B, C, D, E, G>) x),
-                     e -> pure.apply(e(e)).fmap(x -> (Choice6<A, B, C, D, E, G>) x),
-                     f -> fn.apply(f).fmap(Choice6::f));
+    @SuppressWarnings("unchecked")
+    public <G, App extends Applicative, TravB extends Traversable<G, Choice6<A, B, C, D, E, ?>>, AppB extends Applicative<G, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super F, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) Choice6.<A, B, C, D, E, G>a(a)).coerce(),
+                     b -> pure.apply((TravB) Choice6.<A, B, C, D, E, G>b(b)).coerce(),
+                     c -> pure.apply((TravB) Choice6.<A, B, C, D, E, G>c(c)),
+                     d -> pure.apply((TravB) Choice6.<A, B, C, D, E, G>d(d)),
+                     e -> pure.apply((TravB) Choice6.<A, B, C, D, E, G>e(e)),
+                     f -> fn.apply(f).fmap(Choice6::f).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice7.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice7.java
index 920a707db..18d9bdc9e 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice7.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice7.java
@@ -101,16 +101,16 @@ public <H> Choice7<A, B, C, D, E, F, H> flatMap(
     }
 
     @Override
-    public <H, App extends Applicative> Applicative<Choice7<A, B, C, D, E, F, H>, App> traverse(
-            Function<? super G, ? extends Applicative<H, App>> fn,
-            Function<? super Traversable<H, Choice7<A, B, C, D, E, F, ?>>, ? extends Applicative<? extends Traversable<H, Choice7<A, B, C, D, E, F, ?>>, App>> pure) {
-        return match(a -> pure.apply(a(a)).fmap(x -> (Choice7<A, B, C, D, E, F, H>) x),
-                     b -> pure.apply(b(b)).fmap(x -> (Choice7<A, B, C, D, E, F, H>) x),
-                     c -> pure.apply(c(c)).fmap(x -> (Choice7<A, B, C, D, E, F, H>) x),
-                     d -> pure.apply(d(d)).fmap(x -> (Choice7<A, B, C, D, E, F, H>) x),
-                     e -> pure.apply(e(e)).fmap(x -> (Choice7<A, B, C, D, E, F, H>) x),
-                     f -> pure.apply(f(f)).fmap(x -> (Choice7<A, B, C, D, E, F, H>) x),
-                     g -> fn.apply(g).fmap(Choice7::g));
+    @SuppressWarnings("unchecked")
+    public <H, App extends Applicative, TravB extends Traversable<H, Choice7<A, B, C, D, E, F, ?>>, AppB extends Applicative<H, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super G, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) Choice7.<A, B, C, D, E, F, H>a(a)).coerce(),
+                     b -> pure.apply((TravB) Choice7.<A, B, C, D, E, F, H>b(b)).coerce(),
+                     c -> pure.apply((TravB) Choice7.<A, B, C, D, E, F, H>c(c)),
+                     d -> pure.apply((TravB) Choice7.<A, B, C, D, E, F, H>d(d)),
+                     e -> pure.apply((TravB) Choice7.<A, B, C, D, E, F, H>e(e)),
+                     f -> pure.apply((TravB) Choice7.<A, B, C, D, E, F, H>f(f)),
+                     g -> fn.apply(g).fmap(Choice7::g).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice8.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice8.java
index b9d070c39..e7ec41a49 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice8.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice8.java
@@ -97,17 +97,17 @@ public <I> Choice8<A, B, C, D, E, F, G, I> flatMap(
     }
 
     @Override
-    public <I, App extends Applicative> Applicative<Choice8<A, B, C, D, E, F, G, I>, App> traverse(
-            Function<? super H, ? extends Applicative<I, App>> fn,
-            Function<? super Traversable<I, Choice8<A, B, C, D, E, F, G, ?>>, ? extends Applicative<? extends Traversable<I, Choice8<A, B, C, D, E, F, G, ?>>, App>> pure) {
-        return match(a -> pure.apply(a(a)).fmap(x -> (Choice8<A, B, C, D, E, F, G, I>) x),
-                     b -> pure.apply(b(b)).fmap(x -> (Choice8<A, B, C, D, E, F, G, I>) x),
-                     c -> pure.apply(c(c)).fmap(x -> (Choice8<A, B, C, D, E, F, G, I>) x),
-                     d -> pure.apply(d(d)).fmap(x -> (Choice8<A, B, C, D, E, F, G, I>) x),
-                     e -> pure.apply(e(e)).fmap(x -> (Choice8<A, B, C, D, E, F, G, I>) x),
-                     f -> pure.apply(f(f)).fmap(x -> (Choice8<A, B, C, D, E, F, G, I>) x),
-                     g -> pure.apply(g(g)).fmap(x -> (Choice8<A, B, C, D, E, F, G, I>) x),
-                     h -> fn.apply(h).fmap(Choice8::h));
+    @SuppressWarnings("unchecked")
+    public <I, App extends Applicative, TravB extends Traversable<I, Choice8<A, B, C, D, E, F, G, ?>>, AppB extends Applicative<I, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super H, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(a -> pure.apply((TravB) Choice8.<A, B, C, D, E, F, G, I>a(a)).coerce(),
+                     b -> pure.apply((TravB) Choice8.<A, B, C, D, E, F, G, I>b(b)).coerce(),
+                     c -> pure.apply((TravB) Choice8.<A, B, C, D, E, F, G, I>c(c)),
+                     d -> pure.apply((TravB) Choice8.<A, B, C, D, E, F, G, I>d(d)),
+                     e -> pure.apply((TravB) Choice8.<A, B, C, D, E, F, G, I>e(e)),
+                     f -> pure.apply((TravB) Choice8.<A, B, C, D, E, F, G, I>f(f)),
+                     g -> pure.apply((TravB) Choice8.<A, B, C, D, E, F, G, I>g(g)),
+                     h -> fn.apply(h).fmap(Choice8::h).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
index 1dae649b5..0a8143d84 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
@@ -61,10 +61,10 @@ public <_1Prime> SingletonHList<_1Prime> flatMap(Function<? super _1, ? extends
     }
 
     @Override
-    public <_1Prime, App extends Applicative> Applicative<SingletonHList<_1Prime>, App> traverse(
-            Function<? super _1, ? extends Applicative<_1Prime, App>> fn,
-            Function<? super Traversable<_1Prime, SingletonHList>, ? extends Applicative<? extends Traversable<_1Prime, SingletonHList>, App>> pure) {
-        return fn.apply(head()).fmap(SingletonHList::new);
+    @SuppressWarnings("unchecked")
+    public <B, App extends Applicative, TravB extends Traversable<B, SingletonHList>, AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _1, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(head()).fmap(SingletonHList::new).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java
index 00083fac4..173bed228 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java
@@ -135,10 +135,10 @@ public <_2Prime> Tuple2<_1, _2Prime> flatMap(Function<? super _2, ? extends Mona
     }
 
     @Override
-    public <_2Prime, App extends Applicative> Applicative<Tuple2<_1, _2Prime>, App> traverse(
-            Function<? super _2, ? extends Applicative<_2Prime, App>> fn,
-            Function<? super Traversable<_2Prime, Tuple2<_1, ?>>, ? extends Applicative<? extends Traversable<_2Prime, Tuple2<_1, ?>>, App>> pure) {
-        return fn.apply(_2).fmap(_2Prime -> fmap(constantly(_2Prime)));
+    @SuppressWarnings("unchecked")
+    public <_2Prime, App extends Applicative, TravB extends Traversable<_2Prime, Tuple2<_1, ?>>, AppB extends Applicative<_2Prime, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _2, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(_2).fmap(_2Prime -> fmap(constantly(_2Prime))).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
@@ -154,7 +154,7 @@ public static <K, V> Tuple2<K, V> fromEntry(Map.Entry<K, V> entry) {
     }
 
     /**
-     * Given a value of type <code>A</code>, produced an instance of this tuple with each slot set to that value.
+     * Given a value of type <code>A</code>, produce an instance of this tuple with each slot set to that value.
      *
      * @param a   the value to fill the tuple with
      * @param <A> the value type
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java
index 10511c10a..55ddb87b5 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java
@@ -133,10 +133,10 @@ public <_3Prime> Tuple3<_1, _2, _3Prime> flatMap(
     }
 
     @Override
-    public <_3Prime, App extends Applicative> Applicative<Tuple3<_1, _2, _3Prime>, App> traverse(
-            Function<? super _3, ? extends Applicative<_3Prime, App>> fn,
-            Function<? super Traversable<_3Prime, Tuple3<_1, _2, ?>>, ? extends Applicative<? extends Traversable<_3Prime, Tuple3<_1, _2, ?>>, App>> pure) {
-        return fn.apply(_3).fmap(_3Prime -> fmap(constantly(_3Prime)));
+    @SuppressWarnings("unchecked")
+    public <_3Prime, App extends Applicative, TravB extends Traversable<_3Prime, Tuple3<_1, _2, ?>>, AppB extends Applicative<_3Prime, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _3, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(_3).fmap(_3Prime -> fmap(constantly(_3Prime))).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java
index 7e0f21ea0..92347c62a 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java
@@ -145,10 +145,10 @@ public <_4Prime> Tuple4<_1, _2, _3, _4Prime> flatMap(
     }
 
     @Override
-    public <_4Prime, App extends Applicative> Applicative<Tuple4<_1, _2, _3, _4Prime>, App> traverse(
-            Function<? super _4, ? extends Applicative<_4Prime, App>> fn,
-            Function<? super Traversable<_4Prime, Tuple4<_1, _2, _3, ?>>, ? extends Applicative<? extends Traversable<_4Prime, Tuple4<_1, _2, _3, ?>>, App>> pure) {
-        return fn.apply(_4).fmap(_4Prime -> fmap(constantly(_4Prime)));
+    @SuppressWarnings("unchecked")
+    public <_4Prime, App extends Applicative, TravB extends Traversable<_4Prime, Tuple4<_1, _2, _3, ?>>, AppB extends Applicative<_4Prime, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _4, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(_4).fmap(_4Prime -> fmap(constantly(_4Prime))).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java
index 065aef622..d087d4a48 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java
@@ -156,10 +156,10 @@ public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> flatMap(
     }
 
     @Override
-    public <_5Prime, App extends Applicative> Applicative<Tuple5<_1, _2, _3, _4, _5Prime>, App> traverse(
-            Function<? super _5, ? extends Applicative<_5Prime, App>> fn,
-            Function<? super Traversable<_5Prime, Tuple5<_1, _2, _3, _4, ?>>, ? extends Applicative<? extends Traversable<_5Prime, Tuple5<_1, _2, _3, _4, ?>>, App>> pure) {
-        return fn.apply(_5).fmap(_5Prime -> fmap(constantly(_5Prime)));
+    @SuppressWarnings("unchecked")
+    public <_5Prime, App extends Applicative, TravB extends Traversable<_5Prime, Tuple5<_1, _2, _3, _4, ?>>, AppB extends Applicative<_5Prime, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _5, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(_5).fmap(_3Prime -> fmap(constantly(_3Prime))).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple6.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple6.java
index 5bba3c052..2d7e21ab6 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple6.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple6.java
@@ -171,10 +171,10 @@ public <_6Prime> Tuple6<_1, _2, _3, _4, _5, _6Prime> flatMap(
     }
 
     @Override
-    public <_6Prime, App extends Applicative> Applicative<Tuple6<_1, _2, _3, _4, _5, _6Prime>, App> traverse(
-            Function<? super _6, ? extends Applicative<_6Prime, App>> fn,
-            Function<? super Traversable<_6Prime, Tuple6<_1, _2, _3, _4, _5, ?>>, ? extends Applicative<? extends Traversable<_6Prime, Tuple6<_1, _2, _3, _4, _5, ?>>, App>> pure) {
-        return fn.apply(_6).fmap(_6Prime -> fmap(constantly(_6Prime)));
+    @SuppressWarnings("unchecked")
+    public <_6Prime, App extends Applicative, TravB extends Traversable<_6Prime, Tuple6<_1, _2, _3, _4, _5, ?>>, AppB extends Applicative<_6Prime, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _6, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(_6).fmap(_6Prime -> fmap(constantly(_6Prime))).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple7.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple7.java
index bbe9ec79d..28f47406c 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple7.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple7.java
@@ -186,10 +186,10 @@ public <_7Prime> Tuple7<_1, _2, _3, _4, _5, _6, _7Prime> flatMap(
     }
 
     @Override
-    public <_7Prime, App extends Applicative> Applicative<Tuple7<_1, _2, _3, _4, _5, _6, _7Prime>, App> traverse(
-            Function<? super _7, ? extends Applicative<_7Prime, App>> fn,
-            Function<? super Traversable<_7Prime, Tuple7<_1, _2, _3, _4, _5, _6, ?>>, ? extends Applicative<? extends Traversable<_7Prime, Tuple7<_1, _2, _3, _4, _5, _6, ?>>, App>> pure) {
-        return fn.apply(_7).fmap(_7Prime -> fmap(constantly(_7Prime)));
+    @SuppressWarnings("unchecked")
+    public <_7Prime, App extends Applicative, TravB extends Traversable<_7Prime, Tuple7<_1, _2, _3, _4, _5, _6, ?>>, AppB extends Applicative<_7Prime, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _7, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(_7).fmap(_7Prime -> fmap(constantly(_7Prime))).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple8.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple8.java
index 2a1d1615d..1226cc395 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple8.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple8.java
@@ -199,10 +199,10 @@ public <_8Prime> Tuple8<_1, _2, _3, _4, _5, _6, _7, _8Prime> flatMap(
     }
 
     @Override
-    public <_8Prime, App extends Applicative> Applicative<Tuple8<_1, _2, _3, _4, _5, _6, _7, _8Prime>, App> traverse(
-            Function<? super _8, ? extends Applicative<_8Prime, App>> fn,
-            Function<? super Traversable<_8Prime, Tuple8<_1, _2, _3, _4, _5, _6, _7, ?>>, ? extends Applicative<? extends Traversable<_8Prime, Tuple8<_1, _2, _3, _4, _5, _6, _7, ?>>, App>> pure) {
-        return fn.apply(_8).fmap(_8Prime -> fmap(constantly(_8Prime)));
+    @SuppressWarnings("unchecked")
+    public <_8Prime, App extends Applicative, TravB extends Traversable<_8Prime, Tuple8<_1, _2, _3, _4, _5, _6, _7, ?>>, AppB extends Applicative<_8Prime, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super _8, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return fn.apply(_8).fmap(_8Prime -> fmap(constantly(_8Prime))).<TravB>fmap(Applicative::coerce).coerce();
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java b/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java
index 48d60db79..83fc47f11 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java
@@ -3,14 +3,21 @@
 import com.jnape.palatable.lambda.adt.Maybe;
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Set;
 import java.util.function.Consumer;
 
+import static com.jnape.palatable.lambda.adt.Maybe.maybe;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
+import static com.jnape.palatable.lambda.lens.functions.View.view;
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.singletonMap;
 
@@ -35,12 +42,13 @@ private HMap(Map<TypeSafeKey, Object> table) {
      * Retrieve the value at this key.
      *
      * @param key the key
-     * @param <T> the value type
+     * @param <A> the value type
+     * @param <B> the value type
      * @return Maybe the value at this key
      */
     @SuppressWarnings("unchecked")
-    public <T> Maybe<T> get(TypeSafeKey<T> key) {
-        return Maybe.maybe((T) table.get(key));
+    public <A, B> Maybe<B> get(TypeSafeKey<A, B> key) {
+        return maybe((A) table.get(key)).fmap(view(key));
     }
 
     /**
@@ -51,7 +59,7 @@ public <T> Maybe<T> get(TypeSafeKey<T> key) {
      * @return the value at this key
      * @throws NoSuchElementException if the key is unmapped
      */
-    public <V> V demand(TypeSafeKey<V> key) throws NoSuchElementException {
+    public <V> V demand(TypeSafeKey<?, V> key) throws NoSuchElementException {
         return get(key).orElseThrow(() -> new NoSuchElementException("Demanded value for key " + key + ", but couldn't find one."));
     }
 
@@ -63,8 +71,8 @@ public <V> V demand(TypeSafeKey<V> key) throws NoSuchElementException {
      * @param <V>   the value type
      * @return the updated HMap
      */
-    public <V> HMap put(TypeSafeKey<V> key, V value) {
-        return alter(t -> t.put(key, value));
+    public <V> HMap put(TypeSafeKey<?, V> key, V value) {
+        return alter(t -> t.put(key, view(key.mirror(), value)));
     }
 
     /**
@@ -109,20 +117,23 @@ public HMap removeAll(HMap hMap) {
 
     /**
      * Retrieve all the mapped keys.
+     * <p>
+     * Note that unlike with {@link Map#keySet()}, the resulting key set is not "live"; in fact
+     * that is, alterations to the resulting key set have no effect on the backing {@link HMap}.
      *
-     * @return an Iterable of all the mapped keys
+     * @return a {@link Set} of all the mapped keys
      */
-    public Iterable<TypeSafeKey> keys() {
-        return map(Tuple2::_1, this);
+    public Set<TypeSafeKey> keys() {
+        return new HashSet<>(table.keySet());
     }
 
     /**
      * Retrieve all the mapped values.
      *
-     * @return an Iterable of all the mapped values
+     * @return a {@link List} of all the mapped values
      */
-    public Iterable<Object> values() {
-        return map(Tuple2::_2, this);
+    public Collection<Object> values() {
+        return new ArrayList<>(table.values());
     }
 
     /**
@@ -184,7 +195,7 @@ public static HMap emptyHMap() {
      * @param <V>   the only mapped value type
      * @return a singleton HMap
      */
-    public static <V> HMap singletonHMap(TypeSafeKey<V> key, V value) {
+    public static <V> HMap singletonHMap(TypeSafeKey<?, V> key, V value) {
         return new HMap(singletonMap(key, value));
     }
 
@@ -199,8 +210,8 @@ public static <V> HMap singletonHMap(TypeSafeKey<V> key, V value) {
      * @param <V2>   value2's type
      * @return an HMap with the given associations
      */
-    public static <V1, V2> HMap hMap(TypeSafeKey<V1> key1, V1 value1,
-                                     TypeSafeKey<V2> key2, V2 value2) {
+    public static <V1, V2> HMap hMap(TypeSafeKey<?, V1> key1, V1 value1,
+                                     TypeSafeKey<?, V2> key2, V2 value2) {
         return singletonHMap(key1, value1).put(key2, value2);
     }
 
@@ -218,9 +229,9 @@ public static <V1, V2> HMap hMap(TypeSafeKey<V1> key1, V1 value1,
      * @param <V3>   value3's type
      * @return an HMap with the given associations
      */
-    public static <V1, V2, V3> HMap hMap(TypeSafeKey<V1> key1, V1 value1,
-                                         TypeSafeKey<V2> key2, V2 value2,
-                                         TypeSafeKey<V3> key3, V3 value3) {
+    public static <V1, V2, V3> HMap hMap(TypeSafeKey<?, V1> key1, V1 value1,
+                                         TypeSafeKey<?, V2> key2, V2 value2,
+                                         TypeSafeKey<?, V3> key3, V3 value3) {
         return hMap(key1, value1, key2, value2).put(key3, value3);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java b/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java
index 576b87d5c..a71e4c04c 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java
@@ -1,25 +1,106 @@
 package com.jnape.palatable.lambda.adt.hmap;
 
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.functor.Functor;
+import com.jnape.palatable.lambda.functor.Profunctor;
+import com.jnape.palatable.lambda.lens.Iso;
+import com.jnape.palatable.lambda.lens.LensLike;
+
 /**
- * An interface representing a parametrized key for use in HMaps. The parameter specifies the type of the value stored
- * at this binding inside the HMap.
+ * An interface representing a parametrized key for use in {@link HMap}s. Additionally, every {@link TypeSafeKey} is an
+ * {@link Iso} from the type the value is stored as to the type it's viewed and set as (on the way in / on the way out).
+ * This allows multiple keys to map to the same value, but to view the value as different types.
  * <p>
- * This is intentionally an interface so user-defined implementations are possible; however, it's important to note that
- * all hopes of type-safety hinge on equality being implemented such that no two TypeSafeKeys with differing parameters
- * may be considered equal. Reference equality is used here as the default, as that is sufficient.
+ * This is intentionally an interface so user-defined implementations are possible; however, it's important to note
+ * that all hopes of type-safety hinge on equality being implemented such that no two {@link TypeSafeKey}s with
+ * differing value-type parameters may be considered equal. Reference equality is used here as the default, as that is
+ * sufficient.
  *
- * @param <T> The type of the value that this key maps to inside an HMap
+ * @param <A> The raw type of the value that this key maps to inside an {@link HMap}
+ * @param <B> The mapped type of the value that this key maps to inside an {@link HMap}
  */
-public interface TypeSafeKey<T> {
+public interface TypeSafeKey<A, B> extends Iso.Simple<A, B> {
+
+    @Override
+    default <U> TypeSafeKey<A, B> discardR(Applicative<U, LensLike<A, ?, B, B, Iso>> appB) {
+        Iso.Simple<A, B> discarded = Iso.Simple.super.discardR(appB);
+        return new TypeSafeKey<A, B>() {
+            @Override
+            public <P extends Profunctor, F extends Functor, FB extends Functor<B, F>, FT extends Functor<A, F>, PAFB extends Profunctor<B, FB, P>, PSFT extends Profunctor<A, FT, P>> PSFT apply(
+                    PAFB pafb) {
+                return discarded.<P, F, FB, FT, PAFB, PSFT>apply(pafb);
+            }
+
+            @Override
+            public int hashCode() {
+                return TypeSafeKey.this.hashCode();
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                return TypeSafeKey.this.equals(obj);
+            }
+        };
+    }
 
     /**
-     * Static factory method for creating a unique type-safe key
+     * Left-to-right composition of this {@link TypeSafeKey} with some other {@link Iso}. Because the first parameter
+     * fundamentally represents an already stored value type, this is the only composition that is possible for
+     * {@link TypeSafeKey}, which is why only this (and not {@link Iso#compose(Iso)}) is overridden.
+     * <p>
+     * Particularly of note is the fact that values stored at this key are still stored as their original manifest
+     * type, and are not duplicated - which is to say, putting a value at a key, yielding a new key via composition,
+     * and putting a new value at the new key still only results in a single entry in the {@link HMap}. Additionally,
+     * all previous keys involved in the new key's composition are still able to resolve the value in their native type.
      *
-     * @param <T> the type of value stored at this key
+     * @param f   the other simple iso
+     * @param <C> the new value type
+     * @return the new {@link TypeSafeKey}
+     */
+    @Override
+    default <C> TypeSafeKey<A, C> andThen(Iso.Simple<B, C> f) {
+        Iso.Simple<A, C> composed = Iso.Simple.super.andThen(f);
+        return new TypeSafeKey<A, C>() {
+            @Override
+            public <P extends Profunctor, F extends Functor, FB extends Functor<C, F>, FT extends Functor<A, F>, PAFB extends Profunctor<C, FB, P>, PSFT extends Profunctor<A, FT, P>> PSFT apply(
+                    PAFB pafb) {
+                return composed.<P, F, FB, FT, PAFB, PSFT>apply(pafb);
+            }
+
+            @Override
+            public int hashCode() {
+                return TypeSafeKey.this.hashCode();
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                return TypeSafeKey.this.equals(obj);
+            }
+        };
+    }
+
+    /**
+     * Static factory method for creating a simple type-safe key
+     *
+     * @param <A> the type of value stored at this key
      * @return a unique type-safe key
      */
-    static <T> TypeSafeKey<T> typeSafeKey() {
-        return new TypeSafeKey<T>() {
+    static <A> Simple<A> typeSafeKey() {
+        return new TypeSafeKey.Simple<A>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public <P extends Profunctor, F extends Functor, FB extends Functor<A, F>, FT extends Functor<A, F>, PAFB extends Profunctor<A, FB, P>, PSFT extends Profunctor<A, FT, P>> PSFT apply(
+                    PAFB pafb) {
+                return (PSFT) pafb;
+            }
         };
     }
-}
+
+    /**
+     * A simplified {@link TypeSafeKey} that can only view a value of type <code>A</code> as an <code>A</code>.
+     *
+     * @param <A> The type of the value that this key maps to inside an {@link HMap}
+     */
+    interface Simple<A> extends TypeSafeKey<A, A> {
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java
index 440d50041..652b5470d 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.iterators.CyclicIterator;
+import com.jnape.palatable.lambda.iteration.CyclicIterable;
 
 import static java.util.Arrays.asList;
 
@@ -20,7 +20,7 @@ private Cycle() {
 
     @Override
     public Iterable<A> apply(Iterable<A> as) {
-        return () -> new CyclicIterator<>(as.iterator());
+        return new CyclicIterable<>(as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Distinct.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Distinct.java
index 197f90abd..8b39ac2a4 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Distinct.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Distinct.java
@@ -1,10 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-
-import java.util.HashMap;
-
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Filter.filter;
+import com.jnape.palatable.lambda.iteration.DistinctIterable;
 
 /**
  * Return an {@link Iterable} of the distinct values from the given input {@link Iterable}.
@@ -19,8 +16,7 @@ private Distinct() {
 
     @Override
     public Iterable<A> apply(Iterable<A> as) {
-        HashMap<A, Boolean> known = new HashMap<>();
-        return filter(a -> known.putIfAbsent(a, true) == null, as);
+        return new DistinctIterable<>(as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Flatten.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Flatten.java
index 0bb35e775..4c88bdec8 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Flatten.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Flatten.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.iterators.FlatteningIterator;
+import com.jnape.palatable.lambda.iteration.FlatteningIterator;
 
 /**
  * Given a nested {@link Iterable} of {@link Iterable}s, return a lazily flattening {@link Iterable}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Init.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Init.java
index 0ba39822b..ced05d274 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Init.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Init.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.iterators.InitIterator;
+import com.jnape.palatable.lambda.iteration.InitIterator;
 
 /**
  * Given an <code>{@link Iterable}&lt;A&gt;</code>, produce an
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Magnetize.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Magnetize.java
new file mode 100644
index 000000000..47c4d3ed8
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Magnetize.java
@@ -0,0 +1,33 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Eq.eq;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.MagnetizeBy.magnetizeBy;
+
+/**
+ * {@link Magnetize} an {@link Iterable} using value equality as the magnetizing function.
+ *
+ * @param <A> the Iterable element type
+ */
+public final class Magnetize<A> implements Fn1<Iterable<A>, Iterable<Iterable<A>>> {
+
+    private static final Magnetize INSTANCE = new Magnetize();
+
+    private Magnetize() {
+    }
+
+    @Override
+    public Iterable<Iterable<A>> apply(Iterable<A> as) {
+        return magnetizeBy(eq().toBiFunction(), as);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Magnetize<A> magnetize() {
+        return INSTANCE;
+    }
+
+    public static <A> Iterable<Iterable<A>> magnetize(Iterable<A> as) {
+        return Magnetize.<A>magnetize().apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java
index 30da5141f..4286dbace 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.iterators.RepetitiousIterator;
+import com.jnape.palatable.lambda.iteration.RepetitiousIterator;
 
 /**
  * Given a value, return an infinite <code>Iterable</code> that repeatedly iterates that value.
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java
index f2ab76ae6..7b50cecbc 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.iterators.ReversingIterator;
+import com.jnape.palatable.lambda.iteration.ReversingIterable;
 
 /**
  * Given an <code>Iterable</code>, return a reversed representation of that <code>Iterable</code>. Note that reversing
@@ -18,7 +18,7 @@ private Reverse() {
 
     @Override
     public Iterable<A> apply(Iterable<A> as) {
-        return () -> new ReversingIterator<>(as.iterator());
+        return new ReversingIterable<>(as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Both.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Both.java
new file mode 100644
index 000000000..04bce60f5
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Both.java
@@ -0,0 +1,51 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn3;
+
+import java.util.function.Function;
+
+/**
+ * Given two functions <code>f</code> and <code>g</code>, produce a
+ * <code>{@link Fn1}&lt;A, {@link Tuple2}&lt;B, C&gt;&gt;</code> (the dual application of both functions).
+ *
+ * @param <A> both function's input type
+ * @param <B> the first function return type
+ * @param <C> the second function return type
+ */
+public final class Both<A, B, C> implements Fn3<Function<? super A, ? extends B>, Function<? super A, ? extends C>, A, Tuple2<B, C>> {
+
+    private static final Both INSTANCE = new Both();
+
+    private Both() {
+    }
+
+    @Override
+    public Tuple2<B, C> apply(Function<? super A, ? extends B> f,
+                              Function<? super A, ? extends C> g,
+                              A a) {
+        return Tuple2.fill(a).biMap(f, g);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A, B, C> Both<A, B, C> both() {
+        return INSTANCE;
+    }
+
+    public static <A, B, C> Fn1<Function<? super A, ? extends C>, Fn1<A, Tuple2<B, C>>> both(
+            Function<? super A, ? extends B> f) {
+        return Both.<A, B, C>both().apply(f);
+    }
+
+    public static <A, B, C> Fn1<A, Tuple2<B, C>> both(Function<? super A, ? extends B> f,
+                                                      Function<? super A, ? extends C> g) {
+        return Both.<A, B, C>both(f).apply(g);
+    }
+
+    public static <A, B, C> Tuple2<B, C> both(Function<? super A, ? extends B> f,
+                                              Function<? super A, ? extends C> g,
+                                              A a) {
+        return Both.<A, B, C>both(f, g).apply(a);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java
index ec22bb0ed..aa883f86c 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java
@@ -3,7 +3,7 @@
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.CombinatorialIterator;
+import com.jnape.palatable.lambda.iteration.CombinatorialIterator;
 
 /**
  * Lazily compute the cartesian product of an <code>Iterable&lt;A&gt;</code> and <code>Iterable&lt;B&gt;</code>,
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Cons.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Cons.java
index a4e146cae..bee418871 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Cons.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Cons.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.ConsingIterator;
+import com.jnape.palatable.lambda.iteration.ConsingIterator;
 
 /**
  * Prepend an element to an <code>Iterable</code>.
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java
index a0c1d9082..c286d2da6 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.DroppingIterator;
+import com.jnape.palatable.lambda.iteration.DroppingIterable;
 
 /**
  * Lazily skip the first <code>n</code> elements from an <code>Iterable</code> by returning an <code>Iterable</code>
@@ -22,7 +22,7 @@ private Drop() {
 
     @Override
     public Iterable<A> apply(Integer n, Iterable<A> as) {
-        return () -> new DroppingIterator<>(n, as.iterator());
+        return new DroppingIterable<>(n, as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
index a11472d68..9b87e63b0 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.PredicatedDroppingIterator;
+import com.jnape.palatable.lambda.iteration.PredicatedDroppingIterable;
 
 import java.util.function.Function;
 
@@ -25,7 +25,7 @@ private DropWhile() {
 
     @Override
     public Iterable<A> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
-        return () -> new PredicatedDroppingIterator<>(predicate, as.iterator());
+        return new PredicatedDroppingIterable<>(predicate, as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
index ebad91eb5..787978318 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.FilteringIterator;
+import com.jnape.palatable.lambda.iteration.FilteringIterable;
 
 import java.util.function.Function;
 
@@ -23,7 +23,7 @@ private Filter() {
 
     @Override
     public Iterable<A> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
-        return () -> new FilteringIterator<>(predicate, as.iterator());
+        return new FilteringIterable<>(predicate, as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java
index ebdf7cab7..da93304c3 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.GroupingIterator;
+import com.jnape.palatable.lambda.iteration.GroupingIterator;
 
 /**
  * Lazily group the <code>Iterable</code> by returning an <code>Iterable</code> of smaller <code>Iterable</code>s of
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into3.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into3.java
index 8cbe3b75e..1ab7e302e 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into3.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into3.java
@@ -14,12 +14,12 @@
  * @param <C> the third argument type
  * @param <D> the result type
  */
-public final class Into3<A, B, C, D> implements Fn2<Fn3<A, B, C, D>, Tuple3<A, B, C>, D> {
+public final class Into3<A, B, C, D> implements Fn2<Fn3<? super A, ? super B, ? super C, ? extends D>, Tuple3<A, B, C>, D> {
 
     private static final Into3 INSTANCE = new Into3();
 
     @Override
-    public D apply(Fn3<A, B, C, D> fn, Tuple3<A, B, C> tuple) {
+    public D apply(Fn3<? super A, ? super B, ? super C, ? extends D> fn, Tuple3<A, B, C> tuple) {
         return tuple.into(fn);
     }
 
@@ -28,11 +28,11 @@ public static <A, B, C, D> Into3<A, B, C, D> into3() {
         return INSTANCE;
     }
 
-    public static <A, B, C, D> Fn1<Tuple3<A, B, C>, D> into3(Fn3<A, B, C, D> fn) {
+    public static <A, B, C, D> Fn1<Tuple3<A, B, C>, D> into3(Fn3<? super A, ? super B, ? super C, ? extends D> fn) {
         return Into3.<A, B, C, D>into3().apply(fn);
     }
 
-    public static <A, B, C, D> D into3(Fn3<A, B, C, D> fn, Tuple3<A, B, C> tuple) {
-        return into3(fn).apply(tuple);
+    public static <A, B, C, D> D into3(Fn3<? super A, ? super B, ? super C, ? extends D> fn, Tuple3<A, B, C> tuple) {
+        return Into3.<A, B, C, D>into3(fn).apply(tuple);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into4.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into4.java
index ec879df81..240c0eb58 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into4.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into4.java
@@ -15,12 +15,12 @@
  * @param <D> the fourth argument type
  * @param <E> the result type
  */
-public final class Into4<A, B, C, D, E> implements Fn2<Fn4<A, B, C, D, E>, Tuple4<A, B, C, D>, E> {
+public final class Into4<A, B, C, D, E> implements Fn2<Fn4<? super A, ? super B, ? super C, ? super D, ? extends E>, Tuple4<A, B, C, D>, E> {
 
     private static final Into4 INSTANCE = new Into4();
 
     @Override
-    public E apply(Fn4<A, B, C, D, E> fn, Tuple4<A, B, C, D> tuple) {
+    public E apply(Fn4<? super A, ? super B, ? super C, ? super D, ? extends E> fn, Tuple4<A, B, C, D> tuple) {
         return tuple.into(fn);
     }
 
@@ -29,11 +29,13 @@ public static <A, B, C, D, E> Into4<A, B, C, D, E> into4() {
         return INSTANCE;
     }
 
-    public static <A, B, C, D, E> Fn1<Tuple4<A, B, C, D>, E> into4(Fn4<A, B, C, D, E> fn) {
+    public static <A, B, C, D, E> Fn1<Tuple4<A, B, C, D>, E> into4(
+            Fn4<? super A, ? super B, ? super C, ? super D, ? extends E> fn) {
         return Into4.<A, B, C, D, E>into4().apply(fn);
     }
 
-    public static <A, B, C, D, E> E into4(Fn4<A, B, C, D, E> fn, Tuple4<A, B, C, D> tuple) {
-        return into4(fn).apply(tuple);
+    public static <A, B, C, D, E> E into4(Fn4<? super A, ? super B, ? super C, ? super D, ? extends E> fn,
+                                          Tuple4<A, B, C, D> tuple) {
+        return Into4.<A, B, C, D, E>into4(fn).apply(tuple);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into5.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into5.java
index 91fc50a3a..f74b6966c 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into5.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into5.java
@@ -16,12 +16,13 @@
  * @param <E> the fifth argument type
  * @param <F> the result type
  */
-public final class Into5<A, B, C, D, E, F> implements Fn2<Fn5<A, B, C, D, E, F>, Tuple5<A, B, C, D, E>, F> {
+public final class Into5<A, B, C, D, E, F> implements Fn2<Fn5<? super A, ? super B, ? super C, ? super D, ? super E, ? extends F>, Tuple5<A, B, C, D, E>, F> {
 
     private static final Into5 INSTANCE = new Into5();
 
     @Override
-    public F apply(Fn5<A, B, C, D, E, F> fn, Tuple5<A, B, C, D, E> tuple) {
+    public F apply(Fn5<? super A, ? super B, ? super C, ? super D, ? super E, ? extends F> fn,
+                   Tuple5<A, B, C, D, E> tuple) {
         return tuple.into(fn);
     }
 
@@ -30,11 +31,13 @@ public static <A, B, C, D, E, F> Into5<A, B, C, D, E, F> into5() {
         return INSTANCE;
     }
 
-    public static <A, B, C, D, E, F> Fn1<Tuple5<A, B, C, D, E>, F> into5(Fn5<A, B, C, D, E, F> fn) {
+    public static <A, B, C, D, E, F> Fn1<Tuple5<A, B, C, D, E>, F> into5(
+            Fn5<? super A, ? super B, ? super C, ? super D, ? super E, ? extends F> fn) {
         return Into5.<A, B, C, D, E, F>into5().apply(fn);
     }
 
-    public static <A, B, C, D, E, F> F into5(Fn5<A, B, C, D, E, F> fn, Tuple5<A, B, C, D, E> tuple) {
-        return into5(fn).apply(tuple);
+    public static <A, B, C, D, E, F> F into5(Fn5<? super A, ? super B, ? super C, ? super D, ? super E, ? extends F> fn,
+                                             Tuple5<A, B, C, D, E> tuple) {
+        return Into5.<A, B, C, D, E, F>into5(fn).apply(tuple);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into6.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into6.java
index 9f9152574..50e68ef70 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into6.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into6.java
@@ -18,12 +18,13 @@
  * @param <F> the sixth argument type
  * @param <G> the result type
  */
-public final class Into6<A, B, C, D, E, F, G> implements Fn2<Fn6<A, B, C, D, E, F, G>, Tuple6<A, B, C, D, E, F>, G> {
+public final class Into6<A, B, C, D, E, F, G> implements Fn2<Fn6<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? extends G>, Tuple6<A, B, C, D, E, F>, G> {
 
     private static final Into6 INSTANCE = new Into6();
 
     @Override
-    public G apply(Fn6<A, B, C, D, E, F, G> fn, Tuple6<A, B, C, D, E, F> tuple) {
+    public G apply(Fn6<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? extends G> fn,
+                   Tuple6<A, B, C, D, E, F> tuple) {
         return tuple.into(fn);
     }
 
@@ -32,11 +33,14 @@ public static <A, B, C, D, E, F, G> Into6<A, B, C, D, E, F, G> into6() {
         return INSTANCE;
     }
 
-    public static <A, B, C, D, E, F, G> Fn1<Tuple6<A, B, C, D, E, F>, G> into6(Fn6<A, B, C, D, E, F, G> fn) {
+    public static <A, B, C, D, E, F, G> Fn1<Tuple6<A, B, C, D, E, F>, G> into6(
+            Fn6<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? extends G> fn) {
         return Into6.<A, B, C, D, E, F, G>into6().apply(fn);
     }
 
-    public static <A, B, C, D, E, F, G> G into6(Fn6<A, B, C, D, E, F, G> fn, Tuple6<A, B, C, D, E, F> tuple) {
-        return into6(fn).apply(tuple);
+    public static <A, B, C, D, E, F, G> G into6(
+            Fn6<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? extends G> fn,
+            Tuple6<A, B, C, D, E, F> tuple) {
+        return Into6.<A, B, C, D, E, F, G>into6(fn).apply(tuple);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into7.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into7.java
index b2a527861..c814d4b3e 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into7.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into7.java
@@ -19,12 +19,13 @@
  * @param <G> the seventh argument type
  * @param <H> the result type
  */
-public final class Into7<A, B, C, D, E, F, G, H> implements Fn2<Fn7<A, B, C, D, E, F, G, H>, Tuple7<A, B, C, D, E, F, G>, H> {
+public final class Into7<A, B, C, D, E, F, G, H> implements Fn2<Fn7<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? extends H>, Tuple7<A, B, C, D, E, F, G>, H> {
 
     private static final Into7 INSTANCE = new Into7();
 
     @Override
-    public H apply(Fn7<A, B, C, D, E, F, G, H> fn, Tuple7<A, B, C, D, E, F, G> tuple) {
+    public H apply(Fn7<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? extends H> fn,
+                   Tuple7<A, B, C, D, E, F, G> tuple) {
         return tuple.into(fn);
     }
 
@@ -33,11 +34,14 @@ public static <A, B, C, D, E, F, G, H> Into7<A, B, C, D, E, F, G, H> into7() {
         return INSTANCE;
     }
 
-    public static <A, B, C, D, E, F, G, H> Fn1<Tuple7<A, B, C, D, E, F, G>, H> into7(Fn7<A, B, C, D, E, F, G, H> fn) {
+    public static <A, B, C, D, E, F, G, H> Fn1<Tuple7<A, B, C, D, E, F, G>, H> into7(
+            Fn7<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? extends H> fn) {
         return Into7.<A, B, C, D, E, F, G, H>into7().apply(fn);
     }
 
-    public static <A, B, C, D, E, F, G, H> H into7(Fn7<A, B, C, D, E, F, G, H> fn, Tuple7<A, B, C, D, E, F, G> tuple) {
-        return into7(fn).apply(tuple);
+    public static <A, B, C, D, E, F, G, H> H into7(
+            Fn7<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? extends H> fn,
+            Tuple7<A, B, C, D, E, F, G> tuple) {
+        return Into7.<A, B, C, D, E, F, G, H>into7(fn).apply(tuple);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into8.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into8.java
index a454c0bcf..6ac77230b 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into8.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into8.java
@@ -20,12 +20,14 @@
  * @param <H> the eighth argument type
  * @param <I> the result type
  */
-public final class Into8<A, B, C, D, E, F, G, H, I> implements Fn2<Fn8<A, B, C, D, E, F, G, H, I>, Tuple8<A, B, C, D, E, F, G, H>, I> {
+public final class Into8<A, B, C, D, E, F, G, H, I> implements Fn2<Fn8<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? super H, ? extends I>, Tuple8<A, B, C, D, E, F, G, H>, I> {
 
     private static final Into8 INSTANCE = new Into8();
 
     @Override
-    public I apply(Fn8<A, B, C, D, E, F, G, H, I> fn, Tuple8<A, B, C, D, E, F, G, H> tuple) {
+    public I apply(
+            Fn8<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? super H, ? extends I> fn,
+            Tuple8<A, B, C, D, E, F, G, H> tuple) {
         return tuple.into(fn);
     }
 
@@ -35,12 +37,13 @@ public static <A, B, C, D, E, F, G, H, I> Into8<A, B, C, D, E, F, G, H, I> into8
     }
 
     public static <A, B, C, D, E, F, G, H, I> Fn1<Tuple8<A, B, C, D, E, F, G, H>, I> into8(
-            Fn8<A, B, C, D, E, F, G, H, I> fn) {
+            Fn8<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? super H, ? extends I> fn) {
         return Into8.<A, B, C, D, E, F, G, H, I>into8().apply(fn);
     }
 
-    public static <A, B, C, D, E, F, G, H, I> I into8(Fn8<A, B, C, D, E, F, G, H, I> fn,
-                                                      Tuple8<A, B, C, D, E, F, G, H> tuple) {
-        return into8(fn).apply(tuple);
+    public static <A, B, C, D, E, F, G, H, I> I into8(
+            Fn8<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, ? super H, ? extends I> fn,
+            Tuple8<A, B, C, D, E, F, G, H> tuple) {
+        return Into8.<A, B, C, D, E, F, G, H, I>into8(fn).apply(tuple);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/MagnetizeBy.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/MagnetizeBy.java
new file mode 100644
index 000000000..a7e512cc7
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/MagnetizeBy.java
@@ -0,0 +1,61 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+import java.util.Collections;
+import java.util.function.BiFunction;
+
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Size.size;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Uncons.uncons;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Cons.cons;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Drop.drop;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Into.into;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Unfoldr.unfoldr;
+
+/**
+ * Given a binary predicate and an <code>{@link Iterable}&lt;A&gt;</code>, return an <code>{@link Iterable}&lt;{@link
+ * Iterable}&lt;A&gt;&gt;</code> of the contiguous groups of elements that match the predicate pairwise.
+ * <p>
+ * Example: <code>magnetizeBy((x, y) -&gt; x &lt;= y, asList(1, 2, 3, 2, 2, 3, 2, 1)); // [[1, 2, 3], [2, 2, 3], [2],
+ * [1]]</code>
+ *
+ * @param <A> the {@link Iterable} element type
+ */
+public final class MagnetizeBy<A> implements Fn2<BiFunction<? super A, ? super A, Boolean>, Iterable<A>, Iterable<Iterable<A>>> {
+
+    private static final MagnetizeBy INSTANCE = new MagnetizeBy();
+
+    private MagnetizeBy() {
+    }
+
+    @Override
+    public Iterable<Iterable<A>> apply(BiFunction<? super A, ? super A, Boolean> predicate, Iterable<A> as) {
+        return () -> uncons(as).fmap(into((A head, Iterable<A> tail) -> {
+            Iterable<A> group = cons(head, unfoldr(into((pivot, ys) -> uncons(ys)
+                    .flatMap(into((y, recurse) -> predicate.apply(pivot, y)
+                                                  ? just(tuple(y, tuple(y, recurse)))
+                                                  : nothing()))), tuple(head, tail)));
+            return cons(group, () -> apply(predicate, drop(size(group).intValue(), as)).iterator());
+        })).orElseGet(() -> Collections::emptyIterator).iterator();
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> MagnetizeBy<A> magnetizeBy() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<Iterable<A>, Iterable<Iterable<A>>> magnetizeBy(
+            BiFunction<? super A, ? super A, Boolean> predicate) {
+        return MagnetizeBy.<A>magnetizeBy().apply(predicate);
+    }
+
+    public static <A> Iterable<Iterable<A>> magnetizeBy(
+            BiFunction<? super A, ? super A, Boolean> predicate,
+            Iterable<A> as) {
+        return MagnetizeBy.<A>magnetizeBy(predicate).apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java
index 1736edb0f..2b48c2a07 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.MappingIterator;
+import com.jnape.palatable.lambda.iteration.MappingIterable;
 
 import java.util.function.Function;
 
@@ -22,7 +22,7 @@ private Map() {
 
     @Override
     public Iterable<B> apply(Function<? super A, ? extends B> fn, Iterable<A> as) {
-        return () -> new MappingIterator<>(fn, as.iterator());
+        return new MappingIterable<>(fn, as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Peek2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Peek2.java
index 83061c7c6..d544ac7d7 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Peek2.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Peek2.java
@@ -4,6 +4,7 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.Fn3;
 import com.jnape.palatable.lambda.functor.Bifunctor;
+import com.jnape.palatable.lambda.functor.BoundedBifunctor;
 
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -17,7 +18,7 @@
  * @param <B>   the bifunctor's second parameter type
  * @param <FAB> the bifunctor type
  */
-public final class Peek2<A, B, FAB extends Bifunctor<A, B, ?>> implements Fn3<Consumer<? super A>, Consumer<? super B>, FAB, FAB> {
+public final class Peek2<A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> implements Fn3<Consumer<? super A>, Consumer<? super B>, FAB, FAB> {
     private static final Peek2 INSTANCE = new Peek2<>();
 
     private Peek2() {
@@ -36,23 +37,25 @@ public FAB apply(Consumer<? super A> aConsumer, Consumer<? super B> bConsumer, F
     }
 
     @SuppressWarnings("unchecked")
-    public static <A, B, FAB extends Bifunctor<A, B, ?>> Peek2<A, B, FAB> peek2() {
+    public static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Peek2<A, B, FAB> peek2() {
         return INSTANCE;
     }
 
-    public static <A, B, FAB extends Bifunctor<A, B, ?>> Fn2<Consumer<? super B>, FAB, FAB> peek2(
+    public static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn2<Consumer<? super B>, FAB, FAB> peek2(
             Consumer<? super A> aConsumer) {
         return Peek2.<A, B, FAB>peek2().apply(aConsumer);
     }
 
-    public static <A, B, FAB extends Bifunctor<A, B, ?>> Fn1<FAB, FAB> peek2(Consumer<? super A> aConsumer,
-                                                                             Consumer<? super B> bConsumer) {
+    public static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> Fn1<FAB, FAB> peek2(
+            Consumer<? super A> aConsumer,
+            Consumer<? super B> bConsumer) {
         return Peek2.<A, B, FAB>peek2(aConsumer).apply(bConsumer);
     }
 
-    public static <A, B, FAB extends Bifunctor<A, B, ?>> FAB peek2(Consumer<? super A> aConsumer,
-                                                                   Consumer<? super B> bConsumer,
-                                                                   FAB fab) {
+    public static <A, B, FAB extends BoundedBifunctor<A, B, ? super A, ? super B, ?>> FAB peek2(
+            Consumer<? super A> aConsumer,
+            Consumer<? super B> bConsumer,
+            FAB fab) {
         return Peek2.<A, B, FAB>peek2(aConsumer, bConsumer).apply(fab);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/PrependAll.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/PrependAll.java
index da4a3dca7..4c7f26f2a 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/PrependAll.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/PrependAll.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.PrependingIterator;
+import com.jnape.palatable.lambda.iteration.PrependingIterator;
 
 /**
  * Lazily prepend each value with of the <code>Iterable</code> with the supplied separator value. An empty
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Sequence.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Sequence.java
index 3232736e7..198e9feb9 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Sequence.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Sequence.java
@@ -23,11 +23,16 @@
  * @param <A>       the Traversable element type
  * @param <App>     the Applicative unification parameter
  * @param <Trav>    the Traversable unification parameter
+ * @param <AppA>    the Applicative instance wrapped in the input Traversable
+ * @param <TravA>   the Traversable instance wrapped in the output Applicative
  * @param <AppTrav> the concrete parametrized output Applicative type
  * @param <TravApp> the concrete parametrized input Traversable type
  */
-public final class Sequence<A, App extends Applicative, Trav extends Traversable, AppTrav extends Applicative<? extends Traversable<A, Trav>, App>,
-        TravApp extends Traversable<? extends Applicative<A, App>, Trav>> implements Fn2<TravApp, Function<? super Traversable<A, Trav>, ? extends AppTrav>, AppTrav> {
+public final class Sequence<A, App extends Applicative, Trav extends Traversable,
+        AppA extends Applicative<A, App>,
+        TravA extends Traversable<A, Trav>,
+        AppTrav extends Applicative<TravA, App>,
+        TravApp extends Traversable<AppA, Trav>> implements Fn2<TravApp, Function<TravA, ? extends AppTrav>, AppTrav> {
 
     private static final Sequence INSTANCE = new Sequence();
 
@@ -35,44 +40,47 @@ private Sequence() {
     }
 
     @Override
-    @SuppressWarnings("unchecked")
-    public AppTrav apply(TravApp traversable, Function<? super Traversable<A, Trav>, ? extends AppTrav> pure) {
-        return (AppTrav) traversable.traverse(id(), pure);
+    public AppTrav apply(TravApp traversable, Function<TravA, ? extends AppTrav> pure) {
+        return traversable.traverse(id(), pure);
     }
 
     @SuppressWarnings("unchecked")
     public static <A, App extends Applicative, Trav extends Traversable,
-            AppTrav extends Applicative<? extends Traversable<A, Trav>, App>,
-            TravApp extends Traversable<? extends Applicative<A, App>, Trav>> Sequence<A, App, Trav, AppTrav, TravApp> sequence() {
+            AppA extends Applicative<A, App>,
+            TravA extends Traversable<A, Trav>,
+            AppTrav extends Applicative<TravA, App>,
+            TravApp extends Traversable<AppA, Trav>> Sequence<A, App, Trav, AppA, TravA, AppTrav, TravApp> sequence() {
         return INSTANCE;
     }
 
     public static <A, App extends Applicative, Trav extends Traversable,
-            AppTrav extends Applicative<? extends Traversable<A, Trav>, App>,
-            TravApp extends Traversable<? extends Applicative<A, App>, Trav>> Fn1<Function<? super Traversable<A, Trav>, ? extends AppTrav>, AppTrav> sequence(
+            AppA extends Applicative<A, App>,
+            TravA extends Traversable<A, Trav>,
+            AppTrav extends Applicative<TravA, App>,
+            TravApp extends Traversable<AppA, Trav>> Fn1<Function<TravA, ? extends AppTrav>, AppTrav> sequence(
             TravApp traversable) {
-        return Sequence.<A, App, Trav, AppTrav, TravApp>sequence().apply(traversable);
+        return Sequence.<A, App, Trav, AppA, TravA, AppTrav, TravApp>sequence().apply(traversable);
     }
 
     public static <A, App extends Applicative, Trav extends Traversable,
-            AppTrav extends Applicative<? extends Traversable<A, Trav>, App>,
-            TravApp extends Traversable<? extends Applicative<A, App>, Trav>> AppTrav sequence(TravApp traversable,
-                                                                                               Function<? super Traversable<A, Trav>, ? extends AppTrav> pure) {
-        return Sequence.<A, App, Trav, AppTrav, TravApp>sequence(traversable).apply(pure);
+            TravA extends Traversable<A, Trav>,
+            AppA extends Applicative<A, App>,
+            AppTrav extends Applicative<TravA, App>,
+            TravApp extends Traversable<AppA, Trav>> AppTrav sequence(TravApp traversable,
+                                                                      Function<TravA, ? extends AppTrav> pure) {
+        return Sequence.<A, App, Trav, AppA, TravA, AppTrav, TravApp>sequence(traversable).apply(pure);
     }
 
-    @SuppressWarnings("unchecked")
-    public static <A, App extends Applicative, AppIterable extends Applicative<Iterable<A>, App>, IterableApp extends Iterable<? extends Applicative<A, App>>> Fn1<Function<? super Iterable<A>, ? extends AppIterable>, AppIterable> sequence(
-            IterableApp iterableApp) {
-        return pure ->
-                (AppIterable) sequence(LambdaIterable.wrap(iterableApp), x -> pure.apply(((LambdaIterable<A>) x).unwrap())
-                        .fmap(LambdaIterable::wrap))
-                        .fmap(LambdaIterable::unwrap);
+    @SuppressWarnings({"unchecked", "RedundantTypeArguments"})
+    public static <A, App extends Applicative, AppA extends Applicative<A, App>, AppIterable extends Applicative<Iterable<A>, App>, IterableApp extends Iterable<AppA>>
+    Fn1<Function<Iterable<A>, ? extends AppIterable>, AppIterable> sequence(IterableApp iterableApp) {
+        return pure -> (AppIterable) Sequence.<A, App, LambdaIterable, LambdaIterable<A>, AppA, Applicative<LambdaIterable<A>, App>, LambdaIterable<AppA>>sequence(
+                LambdaIterable.wrap(iterableApp), x -> pure.apply(x.unwrap()).fmap(LambdaIterable::wrap))
+                .fmap(LambdaIterable::unwrap);
     }
 
-    public static <A, App extends Applicative, AppIterable extends Applicative<Iterable<A>, App>,
-            IterableApp extends Iterable<? extends Applicative<A, App>>> AppIterable sequence(IterableApp iterableApp,
-                                                                                              Function<? super Iterable<A>, ? extends AppIterable> pure) {
-        return Sequence.<A, App, AppIterable, IterableApp>sequence(iterableApp).apply(pure);
+    public static <A, App extends Applicative, AppA extends Applicative<A, App>, AppIterable extends Applicative<Iterable<A>, App>, IterableApp extends Iterable<AppA>>
+    AppIterable sequence(IterableApp iterableApp, Function<Iterable<A>, ? extends AppIterable> pure) {
+        return Sequence.<A, App, AppA, AppIterable, IterableApp>sequence(iterableApp).apply(pure);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Snoc.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Snoc.java
index 7ef0cec73..6437c0c57 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Snoc.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Snoc.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.SnocIterator;
+import com.jnape.palatable.lambda.iteration.SnocIterable;
 
 /**
  * Opposite of {@link Cons}: lazily append an element to the end of the given {@link Iterable}.
@@ -22,7 +22,7 @@ private Snoc() {
 
     @Override
     public Iterable<A> apply(A a, Iterable<A> as) {
-        return () -> new SnocIterator<>(a, as);
+        return new SnocIterable<>(a, as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Span.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Span.java
new file mode 100644
index 000000000..cd41bc74a
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Span.java
@@ -0,0 +1,43 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.DropWhile.dropWhile;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.TakeWhile.takeWhile;
+
+/**
+ * Given a predicate, return a {@link Tuple2} where the first slot is the front contiguous elements of an {@link
+ * Iterable} matching the predicate and the second slot is all the remaining elements.
+ *
+ * @param <A> the {@link Iterable} element type
+ */
+public final class Span<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Tuple2<Iterable<A>, Iterable<A>>> {
+
+    private static final Span INSTANCE = new Span();
+
+    private Span() {
+    }
+
+    @Override
+    public Tuple2<Iterable<A>, Iterable<A>> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
+        return Tuple2.fill(as).biMap(takeWhile(predicate), dropWhile(predicate));
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Span<A> span() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<Iterable<A>, Tuple2<Iterable<A>, Iterable<A>>> span(Function<? super A, Boolean> predicate) {
+        return Span.<A>span().apply(predicate);
+    }
+
+    public static <A> Tuple2<Iterable<A>, Iterable<A>> span(Function<? super A, Boolean> predicate,
+                                                            Iterable<A> as) {
+        return Span.<A>span(predicate).apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java
index a67bdcfd4..ed10f75bc 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.TakingIterator;
+import com.jnape.palatable.lambda.iteration.TakingIterable;
 
 /**
  * Lazily limit the <code>Iterable</code> to <code>n</code> elements by returning an <code>Iterable</code> that stops
@@ -22,7 +22,7 @@ private Take() {
 
     @Override
     public Iterable<A> apply(Integer n, Iterable<A> as) {
-        return () -> new TakingIterator<>(n, as.iterator());
+        return new TakingIterable<>(n, as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
index e14f5caf8..0b7bc7621 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
@@ -2,7 +2,7 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.PredicatedTakingIterator;
+import com.jnape.palatable.lambda.iteration.PredicatedTakingIterable;
 
 import java.util.function.Function;
 
@@ -24,7 +24,7 @@ private TakeWhile() {
 
     @Override
     public Iterable<A> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
-        return () -> new PredicatedTakingIterator<>(predicate, as.iterator());
+        return new PredicatedTakingIterable<>(predicate, as);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
index cb0a277b6..9a2cd1b15 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
@@ -4,7 +4,7 @@
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
-import com.jnape.palatable.lambda.iterators.UnfoldingIterator;
+import com.jnape.palatable.lambda.iteration.UnfoldingIterator;
 
 import java.util.function.Function;
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java
index a6af6210b..9cc780a15 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java
@@ -3,7 +3,7 @@
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.Fn3;
-import com.jnape.palatable.lambda.iterators.ScanningIterator;
+import com.jnape.palatable.lambda.iteration.ScanningIterator;
 
 import java.util.function.BiFunction;
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java
index 28a83fdeb..75266b884 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java
@@ -3,7 +3,7 @@
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.Fn3;
-import com.jnape.palatable.lambda.iterators.ZippingIterator;
+import com.jnape.palatable.lambda.iteration.ZippingIterator;
 
 import java.util.function.BiFunction;
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn4/IfThenElse.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn4/IfThenElse.java
new file mode 100644
index 000000000..fe353a497
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn4/IfThenElse.java
@@ -0,0 +1,50 @@
+package com.jnape.palatable.lambda.functions.builtin.fn4;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.functions.Fn3;
+import com.jnape.palatable.lambda.functions.Fn4;
+
+import java.util.function.Function;
+
+public final class IfThenElse<A, B> implements Fn4<Function<? super A, Boolean>, Function<? super A, ? extends B>, Function<? super A, ? extends B>, A, B> {
+
+    private static final IfThenElse INSTANCE = new IfThenElse();
+
+    private IfThenElse() {
+    }
+
+    @Override
+    public B apply(Function<? super A, Boolean> predicate, Function<? super A, ? extends B> thenCase,
+                   Function<? super A, ? extends B> elseCase, A a) {
+        return predicate.apply(a) ? thenCase.apply(a) : elseCase.apply(a);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A, B> IfThenElse<A, B> ifThenElse() {
+        return INSTANCE;
+    }
+
+    public static <A, B> Fn3<Function<? super A, ? extends B>, Function<? super A, ? extends B>, A, B> ifThenElse(
+            Function<? super A, Boolean> predicate) {
+        return IfThenElse.<A, B>ifThenElse().apply(predicate);
+    }
+
+    public static <A, B> Fn2<Function<? super A, ? extends B>, A, B> ifThenElse(
+            Function<? super A, Boolean> predicate, Function<? super A, ? extends B> thenCase) {
+        return IfThenElse.<A, B>ifThenElse(predicate).apply(thenCase);
+    }
+
+    public static <A, B> Fn1<A, B> ifThenElse(
+            Function<? super A, Boolean> predicate, Function<? super A, ? extends B> thenCase,
+            Function<? super A, ? extends B> elseCase) {
+        return IfThenElse.<A, B>ifThenElse(predicate, thenCase).apply(elseCase);
+    }
+
+    public static <A, B> B ifThenElse(
+            Function<? super A, Boolean> predicate, Function<? super A, ? extends B> thenCase,
+            Function<? super A, ? extends B> elseCase,
+            A a) {
+        return ifThenElse(predicate, thenCase, elseCase).apply(a);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResult.java b/src/main/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResult.java
index 2d3bdbf53..555af77e5 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResult.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResult.java
@@ -75,11 +75,9 @@ public <C> RecursiveResult<A, B> discardR(Applicative<C, RecursiveResult<A, ?>>
 
     @Override
     @SuppressWarnings("unchecked")
-    public <C, App extends Applicative> Applicative<RecursiveResult<A, C>, App> traverse(
-            Function<? super B, ? extends Applicative<C, App>> fn,
-            Function<? super Traversable<C, RecursiveResult<A, ?>>, ? extends Applicative<? extends Traversable<C, RecursiveResult<A, ?>>, App>> pure) {
-        return match(__ -> pure.apply(coerce()).fmap(x -> (RecursiveResult<A, C>) x),
-                     b -> fn.apply(b).fmap(this::pure));
+    public <C, App extends Applicative, TravB extends Traversable<C, RecursiveResult<A, ?>>, AppB extends Applicative<C, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super B, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return match(__ -> pure.apply(coerce()), b -> fn.apply(b).fmap(this::pure).<TravB>fmap(Applicative::coerce).coerce());
     }
 
     public static <A, B> RecursiveResult<A, B> recurse(A a) {
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Kleisli.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Kleisli.java
new file mode 100644
index 000000000..433ef410f
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Kleisli.java
@@ -0,0 +1,90 @@
+package com.jnape.palatable.lambda.functions.specialized;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.monad.Monad;
+
+import java.util.function.Function;
+
+/**
+ * The Kleisli arrow of a {@link Monad}, manifest as simply an <code>{@link Fn1}&lt;A, MB&gt;</code>. This can be
+ * thought of as a fixed, portable {@link Monad#flatMap(Function)}.
+ *
+ * @param <A>  the input argument type
+ * @param <M>  the {@link Monad} unification parameter
+ * @param <MB> the output {@link Monad} type
+ */
+@FunctionalInterface
+public interface Kleisli<A, B, M extends Monad, MB extends Monad<B, M>> extends Fn1<A, MB> {
+
+    /**
+     * Left-to-right composition of two compatible {@link Kleisli} arrows, yielding a new {@link Kleisli} arrow.
+     *
+     * @param after the arrow to execute after this one
+     * @param <C>   the new return parameter type
+     * @param <MC>  the {@link Monad} instance to return
+     * @return the composition of the two arrows as a new {@link Kleisli} arrow
+     */
+    default <C, MC extends Monad<C, M>> Kleisli<A, C, M, MC> andThen(Kleisli<B, C, M, MC> after) {
+        return a -> apply(a).flatMap(after).coerce();
+    }
+
+    /**
+     * Right-to-left composition of two compatible {@link Kleisli} arrows, yielding a new {@link Kleisli} arrow.
+     *
+     * @param before the arrow to execute before this one
+     * @param <Z>    the new input argument type
+     * @param <MA>   the {@link Monad} instance to flatMap with this arrow
+     * @return the composition of the two arrows as a new {@link Kleisli} arrow
+     */
+    default <Z, MA extends Monad<A, M>> Kleisli<Z, B, M, MB> compose(Kleisli<Z, A, M, MA> before) {
+        return z -> before.apply(z).flatMap(this).coerce();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <Z> Kleisli<Z, B, M, MB> compose(Function<? super Z, ? extends A> before) {
+        return Fn1.super.compose(before)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <C> Kleisli<A, B, M, MB> discardR(Applicative<C, Fn1<A, ?>> appB) {
+        return Fn1.super.discardR(appB)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <Z> Kleisli<Z, B, M, MB> contraMap(Function<? super Z, ? extends A> fn) {
+        return Fn1.super.contraMap(fn)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default <Z> Kleisli<Z, B, M, MB> diMapL(Function<? super Z, ? extends A> fn) {
+        return Fn1.super.diMapL(fn)::apply;
+    }
+
+    /**
+     * Adapt a compatible function into a {@link Kleisli} arrow.
+     *
+     * @param fn   the function
+     * @param <A>  the input argument type
+     * @param <B>  the output parameter type
+     * @param <M>  the {@link Monad} unification parameter
+     * @param <MB> the returned {@link Monad} instance
+     * @return the function adapted as a {@link Kleisli} arrow
+     */
+    static <A, B, M extends Monad, MB extends Monad<B, M>> Kleisli<A, B, M, MB> kleisli(
+            Function<? super A, ? extends MB> fn) {
+        return fn::apply;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
index f91b83aa4..3d5a9176c 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
@@ -5,11 +5,13 @@
 import static com.jnape.palatable.lambda.functions.specialized.checked.Runtime.throwChecked;
 
 /**
- * Specialized {@link Fn1} that can throw checked exceptions.
+ * Specialized {@link Fn1} that can throw any {@link Throwable}.
  *
+ * @param <T> The {@link Throwable} type
  * @param <A> The input type
  * @param <B> The output type
  * @see CheckedSupplier
+ * @see CheckedRunnable
  * @see Fn1
  */
 @FunctionalInterface
@@ -25,11 +27,11 @@ default B apply(A a) {
     }
 
     /**
-     * A version of {@link Fn1} that can throw checked exceptions.
+     * A version of {@link Fn1#apply} that can throw checked exceptions.
      *
-     * @param a the argument
-     * @return the result of the function application
-     * @throws T any Throwable thrown by the function application
+     * @param a the function argument
+     * @return the application of the argument to the function
+     * @throws T any exception that can be thrown by this method
      */
     B checkedApply(A a) throws T;
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedRunnable.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedRunnable.java
new file mode 100644
index 000000000..2552c746e
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedRunnable.java
@@ -0,0 +1,58 @@
+package com.jnape.palatable.lambda.functions.specialized.checked;
+
+import com.jnape.palatable.lambda.adt.Unit;
+
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+import static com.jnape.palatable.lambda.functions.specialized.checked.Runtime.throwChecked;
+
+/**
+ * Specialized {@link Runnable} that can throw any {@link Throwable}.
+ *
+ * @param <T> The {@link Throwable} type
+ * @see CheckedSupplier
+ * @see CheckedFn1
+ */
+@FunctionalInterface
+public interface CheckedRunnable<T extends Throwable> extends Runnable {
+
+    @Override
+    default void run() {
+        try {
+            checkedRun();
+        } catch (Throwable t) {
+            throw throwChecked(t);
+        }
+    }
+
+    /**
+     * A version of {@link Runnable#run()} that can throw checked exceptions.
+     *
+     * @throws T any exception that can be thrown by this method
+     */
+    void checkedRun() throws T;
+
+    /**
+     * Convert this {@link CheckedRunnable} to a {@link CheckedSupplier} that returns {@link Unit}.
+     *
+     * @return the checked supplier
+     */
+    default CheckedSupplier<T, Unit> toSupplier() {
+        return () -> {
+            run();
+            return UNIT;
+        };
+    }
+
+    /**
+     * Convenience static factory method for constructing a {@link CheckedRunnable} without an explicit cast or type
+     * attribution at the call site.
+     *
+     * @param runnable the checked runnable
+     * @param <T>      the inferred Throwable type
+     * @return the checked runnable
+     */
+    static <T extends Throwable> CheckedRunnable<T> checked(CheckedRunnable<T> runnable) {
+        return runnable::run;
+    }
+
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java
index dd38fc165..b32f1e4b8 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java
@@ -5,17 +5,18 @@
 import static com.jnape.palatable.lambda.functions.specialized.checked.Runtime.throwChecked;
 
 /**
- * Specialized {@link Supplier} that can throw checked exceptions.
+ * Specialized {@link Supplier} that can throw any {@link Throwable}.
  *
- * @param <E> The exception type
- * @param <T> The return type
+ * @param <T> The {@link Throwable} type
+ * @param <A> The return type
  * @see CheckedFn1
+ * @see CheckedRunnable
  */
 @FunctionalInterface
-public interface CheckedSupplier<E extends Throwable, T> extends Supplier<T> {
+public interface CheckedSupplier<T extends Throwable, A> extends Supplier<A> {
 
     @Override
-    default T get() {
+    default A get() {
         try {
             return checkedGet();
         } catch (Throwable t) {
@@ -27,7 +28,29 @@ default T get() {
      * A version of {@link Supplier#get()} that can throw checked exceptions.
      *
      * @return the supplied result
-     * @throws E any exception that can be thrown by this method
+     * @throws T any exception that can be thrown by this method
      */
-    T checkedGet() throws E;
+    A checkedGet() throws T;
+
+    /**
+     * Convert this {@link CheckedSupplier} to a {@link CheckedRunnable}.
+     *
+     * @return the checked runnable
+     */
+    default CheckedRunnable<T> toRunnable() {
+        return this::get;
+    }
+
+    /**
+     * Convenience static factory method for constructing a {@link CheckedSupplier} without an explicit cast or type
+     * attribution at the call site.
+     *
+     * @param supplier the checked supplier
+     * @param <T>      the inferred Throwable type
+     * @param <A>      the supplier return type
+     * @return the checked supplier
+     */
+    static <T extends Throwable, A> CheckedSupplier<T, A> checked(CheckedSupplier<T, A> supplier) {
+        return supplier::get;
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/Runtime.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/Runtime.java
index 810528676..1546e811b 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/Runtime.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/Runtime.java
@@ -3,7 +3,7 @@
 class Runtime {
 
     @SuppressWarnings("unchecked")
-    public static <T extends Throwable> RuntimeException throwChecked(Throwable ex) throws T {
-        throw (T) ex;
+    public static <T extends Throwable> RuntimeException throwChecked(Throwable t) throws T {
+        throw (T) t;
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java b/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java
index f345cdc2d..224963a83 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Applicative.java
@@ -61,7 +61,7 @@ default <B> Applicative<B, App> fmap(Function<? super A, ? extends B> fn) {
      * @return appB
      */
     default <B> Applicative<B, App> discardL(Applicative<B, App> appB) {
-        return appB.zip(zip(pure(constantly(id()))));
+        return appB.zip(fmap(constantly(id())));
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java
index b024bf37b..695c71a8f 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java
@@ -17,7 +17,7 @@
  * @see com.jnape.palatable.lambda.adt.hlist.Tuple2
  */
 @FunctionalInterface
-public interface Bifunctor<A, B, BF extends Bifunctor> {
+public interface Bifunctor<A, B, BF extends Bifunctor> extends BoundedBifunctor<A, B, Object, Object, BF> {
 
     /**
      * Covariantly map over the left parameter.
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/BoundedBifunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/BoundedBifunctor.java
new file mode 100644
index 000000000..02fc7775f
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functor/BoundedBifunctor.java
@@ -0,0 +1,58 @@
+package com.jnape.palatable.lambda.functor;
+
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+
+/**
+ * A {@link Bifunctor} that has both parameter types upper bounded; that is, neither parameters can be mapped to a value
+ * that is not covariant to their respective upper bounds
+ *
+ * @param <A>       The type of the left parameter
+ * @param <B>       The type of the right parameter
+ * @param <ContraA> The type of the left parameter upper type bound
+ * @param <ContraB> The type of the right parameter upper type bound
+ * @param <BF>      The unification parameter
+ * @see Bifunctor
+ */
+@FunctionalInterface
+public interface BoundedBifunctor<A extends ContraA, B extends ContraB, ContraA, ContraB, BF extends BoundedBifunctor> {
+
+    /**
+     * Covariantly map the left parameter into a value that is covariant to <code>ContraA</code>.
+     *
+     * @param fn  the mapping function
+     * @param <C> the new left parameter type
+     * @return a bifunctor of C (the new parameter type) and B (the same right parameter)
+     */
+    default <C extends ContraA> BoundedBifunctor<C, B, ContraA, ContraB, BF> biMapL(
+            Function<? super A, ? extends C> fn) {
+        return biMap(fn, id());
+    }
+
+    /**
+     * Covariantly map the right parameter into a value that is covariant to <code>ContraB</code>.
+     *
+     * @param fn  the mapping function
+     * @param <C> the new right parameter type
+     * @return a bifunctor of A (the same left parameter) and C (the new parameter type)
+     */
+    default <C extends ContraB> BoundedBifunctor<A, C, ContraA, ContraB, BF> biMapR(
+            Function<? super B, ? extends C> fn) {
+        return biMap(id(), fn);
+    }
+
+    /**
+     * Dually covariantly map both the left and right parameters into values that are covariant to <code>ContraA</code>
+     * and <code>ContraB</code>, respectively. This is isomorphic to <code>biMapL(lFn).biMapR(rFn)</code>.
+     *
+     * @param <C> the new left parameter type
+     * @param <D> the new right parameter type
+     * @param lFn the left parameter mapping function
+     * @param rFn the right parameter mapping function
+     * @return a bifunctor over C (the new left parameter type) and D (the new right parameter type)
+     */
+    <C extends ContraA, D extends ContraB> BoundedBifunctor<C, D, ContraA, ContraB, BF> biMap(
+            Function<? super A, ? extends C> lFn,
+            Function<? super B, ? extends D> rFn);
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/builtin/Compose.java b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Compose.java
index a8b260bcf..568988a9d 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/builtin/Compose.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Compose.java
@@ -59,4 +59,11 @@ public boolean equals(Object other) {
     public int hashCode() {
         return Objects.hash(fga);
     }
+
+    @Override
+    public String toString() {
+        return "Compose{" +
+                "fga=" + fga +
+                '}';
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/builtin/Const.java b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Const.java
index 5eea967fb..6de15b769 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/builtin/Const.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Const.java
@@ -1,8 +1,8 @@
 package com.jnape.palatable.lambda.functor.builtin;
 
-import com.jnape.palatable.lambda.monad.Monad;
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Bifunctor;
+import com.jnape.palatable.lambda.monad.Monad;
 import com.jnape.palatable.lambda.traversable.Traversable;
 
 import java.util.Objects;
@@ -34,16 +34,6 @@ public A runConst() {
         return a;
     }
 
-    @Override
-    public boolean equals(Object other) {
-        return other instanceof Const && Objects.equals(a, ((Const) other).a);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(a);
-    }
-
     /**
      * Map over the right parameter. Note that because <code>B</code> is never actually known quantity outside of a type
      * signature, this is effectively a no-op that serves only to alter <code>Const's</code> type signature.
@@ -85,10 +75,9 @@ public <C> Const<A, C> flatMap(Function<? super B, ? extends Monad<C, Const<A, ?
     }
 
     @Override
-    public <C, App extends Applicative> Applicative<Const<A, C>, App> traverse(
-            Function<? super B, ? extends Applicative<C, App>> fn,
-            Function<? super Traversable<C, Const<A, ?>>, ? extends Applicative<? extends Traversable<C, Const<A, ?>>, App>> pure) {
-        return pure.apply(coerce()).fmap(x -> (Const<A, C>) x);
+    public <C, App extends Applicative, TravB extends Traversable<C, Const<A, ?>>, AppB extends Applicative<C, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super B, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return pure.apply(coerce());
     }
 
     /**
@@ -131,4 +120,21 @@ public <C, D> Const<C, D> biMap(Function<? super A, ? extends C> lFn,
                                     Function<? super B, ? extends D> rFn) {
         return new Const<>(lFn.apply(a));
     }
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof Const && Objects.equals(a, ((Const) other).a);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(a);
+    }
+
+    @Override
+    public String toString() {
+        return "Const{" +
+                "a=" + a +
+                '}';
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/builtin/Exchange.java b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Exchange.java
new file mode 100644
index 000000000..1a9439d6b
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Exchange.java
@@ -0,0 +1,56 @@
+package com.jnape.palatable.lambda.functor.builtin;
+
+import com.jnape.palatable.lambda.functor.Profunctor;
+import com.jnape.palatable.lambda.lens.Iso;
+
+import java.util.function.Function;
+
+/**
+ * A profunctor used to extract the isomorphic functions an {@link Iso} is composed of.
+ *
+ * @param <A> the smaller viewed value of an {@link Iso}
+ * @param <B> the smaller viewing value of an {@link Iso}
+ * @param <S> the larger viewing value of an {@link Iso}
+ * @param <T> the larger viewed value of an {@link Iso}
+ */
+public final class Exchange<A, B, S, T> implements Profunctor<S, T, Exchange<A, B, ?, ?>> {
+    private final Function<? super S, ? extends A> sa;
+    private final Function<? super B, ? extends T> bt;
+
+    public Exchange(Function<? super S, ? extends A> sa, Function<? super B, ? extends T> bt) {
+        this.sa = sa;
+        this.bt = bt;
+    }
+
+    public Function<? super S, ? extends A> sa() {
+        return sa;
+    }
+
+    public Function<? super B, ? extends T> bt() {
+        return bt;
+    }
+
+    @Override
+    public <Z, C> Exchange<A, B, Z, C> diMap(Function<? super Z, ? extends S> lFn,
+                                             Function<? super T, ? extends C> rFn) {
+        return new Exchange<>(lFn.andThen(sa), bt.andThen(rFn));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <Z> Exchange<A, B, Z, T> diMapL(Function<? super Z, ? extends S> fn) {
+        return (Exchange<A, B, Z, T>) Profunctor.super.diMapL(fn);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <C> Exchange<A, B, S, C> diMapR(Function<? super T, ? extends C> fn) {
+        return (Exchange<A, B, S, C>) Profunctor.super.diMapR(fn);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <Z> Exchange<A, B, Z, T> contraMap(Function<? super Z, ? extends S> fn) {
+        return (Exchange<A, B, Z, T>) Profunctor.super.contraMap(fn);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/builtin/Identity.java b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Identity.java
index def56eea0..68e223c40 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/builtin/Identity.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/builtin/Identity.java
@@ -66,10 +66,10 @@ public <B> Identity<A> discardR(Applicative<B, Identity> appB) {
     }
 
     @Override
-    public <B, App extends Applicative> Applicative<Identity<B>, App> traverse(
-            Function<? super A, ? extends Applicative<B, App>> fn,
-            Function<? super Traversable<B, Identity>, ? extends Applicative<? extends Traversable<B, Identity>, App>> pure) {
-        return fn.apply(runIdentity()).fmap(Identity::new);
+    @SuppressWarnings("unchecked")
+    public <B, App extends Applicative, TravB extends Traversable<B, Identity>, AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super A, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
+        return (AppTrav) fn.apply(runIdentity()).fmap(Identity::new);
     }
 
     @Override
@@ -81,4 +81,11 @@ public boolean equals(Object other) {
     public int hashCode() {
         return Objects.hash(a);
     }
+
+    @Override
+    public String toString() {
+        return "Identity{" +
+                "a=" + a +
+                '}';
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/CombinatorialIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/CombinatorialIterator.java
similarity index 97%
rename from src/main/java/com/jnape/palatable/lambda/iterators/CombinatorialIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/CombinatorialIterator.java
index 5e4a4dcd4..1aefe0536 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/CombinatorialIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/CombinatorialIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/ConcatenatingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/ConcatenatingIterable.java
new file mode 100644
index 000000000..f7ae08023
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ConcatenatingIterable.java
@@ -0,0 +1,28 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Iterator;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Flatten.flatten;
+
+public final class ConcatenatingIterable<A> implements Iterable<A> {
+
+    private final ImmutableQueue<Iterable<A>> iterables;
+
+    public ConcatenatingIterable(Iterable<A> xs, Iterable<A> ys) {
+        if (xs instanceof ConcatenatingIterable) {
+            ImmutableQueue<Iterable<A>> iterables = ((ConcatenatingIterable<A>) xs).iterables;
+            this.iterables = ys instanceof ConcatenatingIterable
+                             ? iterables.concat(((ConcatenatingIterable<A>) ys).iterables)
+                             : iterables.pushBack(ys);
+        } else {
+            iterables = ys instanceof ConcatenatingIterable
+                        ? ((ConcatenatingIterable<A>) ys).iterables.pushFront(xs)
+                        : ImmutableQueue.<Iterable<A>>empty().pushFront(ys).pushFront(xs);
+        }
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return flatten(iterables).iterator();
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ConsingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/ConsingIterator.java
similarity index 96%
rename from src/main/java/com/jnape/palatable/lambda/iterators/ConsingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/ConsingIterator.java
index c8dee5b3b..d35d92c0b 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ConsingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ConsingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/CyclicIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/CyclicIterable.java
new file mode 100644
index 000000000..6d08dbcf2
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/CyclicIterable.java
@@ -0,0 +1,19 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Iterator;
+
+public final class CyclicIterable<A> implements Iterable<A> {
+    private final Iterable<A> as;
+
+    public CyclicIterable(Iterable<A> as) {
+        while (as instanceof CyclicIterable) {
+            as = ((CyclicIterable<A>) as).as;
+        }
+        this.as = as;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return new CyclicIterator<>(as.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/CyclicIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/CyclicIterator.java
similarity index 95%
rename from src/main/java/com/jnape/palatable/lambda/iterators/CyclicIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/CyclicIterator.java
index 4aa462bb2..ba04f23b8 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/CyclicIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/CyclicIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.ArrayList;
 import java.util.Iterator;
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/DistinctIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/DistinctIterable.java
new file mode 100644
index 000000000..447b76168
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/DistinctIterable.java
@@ -0,0 +1,24 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Filter.filter;
+
+public final class DistinctIterable<A> implements Iterable<A> {
+
+    private final Iterable<A> as;
+
+    public DistinctIterable(Iterable<A> as) {
+        while (as instanceof DistinctIterable) {
+            as = ((DistinctIterable<A>) as).as;
+        }
+        this.as = as;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        HashMap<A, Boolean> known = new HashMap<>();
+        return filter(a -> known.putIfAbsent(a, true) == null, as).iterator();
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/DroppingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/DroppingIterable.java
new file mode 100644
index 000000000..b545a296f
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/DroppingIterable.java
@@ -0,0 +1,23 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Iterator;
+
+public final class DroppingIterable<A> implements Iterable<A> {
+    private final int         n;
+    private final Iterable<A> as;
+
+    public DroppingIterable(int n, Iterable<A> as) {
+        while (as instanceof DroppingIterable) {
+            DroppingIterable<A> nested = (DroppingIterable<A>) as;
+            as = nested.as;
+            n += nested.n;
+        }
+        this.as = as;
+        this.n = n;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return new DroppingIterator<>(n, as.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/DroppingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/DroppingIterator.java
similarity index 62%
rename from src/main/java/com/jnape/palatable/lambda/iterators/DroppingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/DroppingIterator.java
index 48938ff67..e0c543c3f 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/DroppingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/DroppingIterator.java
@@ -1,12 +1,12 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 public class DroppingIterator<A> extends ImmutableIterator<A> {
-    private Integer     n;
-    private Iterator<A> asIterator;
-    private boolean     dropped;
+    private final Integer     n;
+    private final Iterator<A> asIterator;
+    private       boolean     dropped;
 
     public DroppingIterator(Integer n, Iterator<A> asIterator) {
         this.n = n;
@@ -17,9 +17,7 @@ public DroppingIterator(Integer n, Iterator<A> asIterator) {
     @Override
     public boolean hasNext() {
         if (!dropped) {
-            deforest();
             drop();
-            dropped = true;
         }
         return asIterator.hasNext();
     }
@@ -32,16 +30,10 @@ public A next() {
         return asIterator.next();
     }
 
-    private void deforest() {
-        while (asIterator instanceof DroppingIterator) {
-            n += ((DroppingIterator) this.asIterator).n;
-            asIterator = ((DroppingIterator<A>) this.asIterator).asIterator;
-        }
-    }
-
     private void drop() {
         int i = 0;
         while (i++ < n && asIterator.hasNext())
             asIterator.next();
+        dropped = true;
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/FilteringIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/FilteringIterable.java
new file mode 100644
index 000000000..bd7be982c
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/FilteringIterable.java
@@ -0,0 +1,31 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.All.all;
+import static java.util.Collections.singletonList;
+
+public final class FilteringIterable<A> implements Iterable<A> {
+    private final List<Function<? super A, Boolean>> predicates;
+    private final Iterable<A>                        as;
+
+    public FilteringIterable(Function<? super A, Boolean> predicate, Iterable<A> as) {
+        List<Function<? super A, Boolean>> predicates = new ArrayList<>(singletonList(predicate));
+        while (as instanceof FilteringIterable) {
+            FilteringIterable<A> nested = (FilteringIterable<A>) as;
+            predicates.addAll(nested.predicates);
+            as = nested.as;
+        }
+        this.predicates = predicates;
+        this.as = as;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        Function<? super A, Boolean> metaPredicate = a -> all(p -> p.apply(a), predicates);
+        return new FilteringIterator<>(metaPredicate, as.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/FilteringIterator.java
similarity index 95%
rename from src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/FilteringIterator.java
index b95f39eda..75f02db95 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/FilteringIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/FlatteningIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/FlatteningIterator.java
similarity index 85%
rename from src/main/java/com/jnape/palatable/lambda/iterators/FlatteningIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/FlatteningIterator.java
index 7938ce880..40458cd48 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/FlatteningIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/FlatteningIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
@@ -13,7 +13,7 @@ public FlatteningIterator(Iterator<? extends Iterable<? extends A>> xss) {
 
     @Override
     public boolean hasNext() {
-        while (xss.hasNext() && (xs == null || !xs.hasNext()))
+        while ((xs == null || !xs.hasNext()) && xss.hasNext())
             xs = xss.next().iterator();
 
         return xs != null && xs.hasNext();
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/GroupingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/GroupingIterator.java
similarity index 93%
rename from src/main/java/com/jnape/palatable/lambda/iterators/GroupingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/GroupingIterator.java
index 310324b75..6960c87c8 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/GroupingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/GroupingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.ArrayList;
 import java.util.Iterator;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ImmutableIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableIterator.java
similarity index 83%
rename from src/main/java/com/jnape/palatable/lambda/iterators/ImmutableIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/ImmutableIterator.java
index cef1ff254..7252d2313 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ImmutableIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableQueue.java b/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableQueue.java
new file mode 100644
index 000000000..94d94d0b0
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableQueue.java
@@ -0,0 +1,119 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.adt.Maybe;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft;
+
+abstract class ImmutableQueue<A> implements Iterable<A> {
+
+    abstract ImmutableQueue<A> pushFront(A a);
+
+    abstract ImmutableQueue<A> pushBack(A a);
+
+    abstract Maybe<A> head();
+
+    abstract ImmutableQueue<A> tail();
+
+    abstract ImmutableQueue<A> concat(ImmutableQueue<A> other);
+
+    final boolean isEmpty() {
+        return head().fmap(constantly(false)).orElse(true);
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return new Iterator<A>() {
+            private ImmutableQueue<A> queue = ImmutableQueue.this;
+
+            @Override
+            public boolean hasNext() {
+                return !queue.isEmpty();
+            }
+
+            @Override
+            public A next() {
+                A next = queue.head().orElseThrow(NoSuchElementException::new);
+                queue = queue.tail();
+                return next;
+            }
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> ImmutableQueue<A> empty() {
+        return Empty.INSTANCE;
+    }
+
+    private static final class Empty<A> extends ImmutableQueue<A> {
+        private static final Empty INSTANCE = new Empty();
+
+        @Override
+        ImmutableQueue<A> pushFront(A a) {
+            return new NonEmpty<>(ImmutableStack.<A>empty().push(a), ImmutableStack.empty());
+        }
+
+        @Override
+        ImmutableQueue<A> pushBack(A a) {
+            return pushFront(a);
+        }
+
+        @Override
+        ImmutableQueue<A> concat(ImmutableQueue<A> other) {
+            return other;
+        }
+
+        @Override
+        Maybe<A> head() {
+            return Maybe.nothing();
+        }
+
+        @Override
+        ImmutableQueue<A> tail() {
+            return this;
+        }
+    }
+
+    private static final class NonEmpty<A> extends ImmutableQueue<A> {
+        private final ImmutableStack<A> outbound;
+        private final ImmutableStack<A> inbound;
+
+        private NonEmpty(ImmutableStack<A> outbound, ImmutableStack<A> inbound) {
+            this.outbound = outbound;
+            this.inbound = inbound;
+        }
+
+        @Override
+        ImmutableQueue<A> pushFront(A a) {
+            return new NonEmpty<>(outbound.push(a), inbound);
+        }
+
+        @Override
+        ImmutableQueue<A> pushBack(A a) {
+            return new NonEmpty<>(outbound, inbound.push(a));
+        }
+
+        @Override
+        ImmutableQueue<A> concat(ImmutableQueue<A> other) {
+            return new NonEmpty<>(outbound, foldLeft(ImmutableStack::push, inbound, other));
+        }
+
+        @Override
+        Maybe<A> head() {
+            return outbound.head();
+        }
+
+        @Override
+        ImmutableQueue<A> tail() {
+            ImmutableStack<A> outTail = outbound.tail();
+            if (!outTail.isEmpty())
+                return new NonEmpty<>(outTail, inbound);
+
+            ImmutableStack<A> newOutbound = foldLeft(ImmutableStack::push, ImmutableStack.<A>empty(), inbound);
+            return newOutbound.isEmpty() ? empty() : new NonEmpty<>(newOutbound, ImmutableStack.empty());
+        }
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableStack.java b/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableStack.java
new file mode 100644
index 000000000..619619efb
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ImmutableStack.java
@@ -0,0 +1,81 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.adt.Maybe;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+
+abstract class ImmutableStack<A> implements Iterable<A> {
+
+    final ImmutableStack<A> push(A a) {
+        return new Node<>(a, this);
+    }
+
+    abstract Maybe<A> head();
+
+    abstract ImmutableStack<A> tail();
+
+    final boolean isEmpty() {
+        return head().fmap(constantly(false)).orElse(true);
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return new Iterator<A>() {
+            private ImmutableStack<A> stack = ImmutableStack.this;
+
+            @Override
+            public boolean hasNext() {
+                return !stack.isEmpty();
+            }
+
+            @Override
+            public A next() {
+                A next = stack.head().orElseThrow(NoSuchElementException::new);
+                stack = stack.tail();
+                return next;
+            }
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> ImmutableStack<A> empty() {
+        return Empty.INSTANCE;
+    }
+
+    private static final class Empty<A> extends ImmutableStack<A> {
+        private static final Empty INSTANCE = new Empty();
+
+        @Override
+        Maybe<A> head() {
+            return Maybe.nothing();
+        }
+
+        @Override
+        ImmutableStack<A> tail() {
+            return this;
+        }
+    }
+
+    private static final class Node<A> extends ImmutableStack<A> {
+        private final A                 head;
+        private final ImmutableStack<A> tail;
+
+        public Node(A head, ImmutableStack<A> tail) {
+            this.head = head;
+            this.tail = tail;
+        }
+
+        @Override
+        Maybe<A> head() {
+            return Maybe.just(head);
+        }
+
+        @Override
+        ImmutableStack<A> tail() {
+            return tail;
+        }
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/InfiniteIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/InfiniteIterator.java
similarity index 77%
rename from src/main/java/com/jnape/palatable/lambda/iterators/InfiniteIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/InfiniteIterator.java
index b85b1d235..88b7c640d 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/InfiniteIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/InfiniteIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 public abstract class InfiniteIterator<A> extends ImmutableIterator<A> {
     @Override
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/InitIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/InitIterator.java
similarity index 93%
rename from src/main/java/com/jnape/palatable/lambda/iterators/InitIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/InitIterator.java
index 0de021061..e89ebf1fb 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/InitIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/InitIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/MappingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/MappingIterable.java
new file mode 100644
index 000000000..1730a6838
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/MappingIterable.java
@@ -0,0 +1,33 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft;
+import static java.util.Collections.singletonList;
+
+public final class MappingIterable<A, B> implements Iterable<B> {
+    private final Iterable       as;
+    private final List<Function> mappers;
+
+    @SuppressWarnings("unchecked")
+    public MappingIterable(Function<? super A, ? extends B> fn, Iterable<A> as) {
+        List<Function> mappers = new ArrayList<>(singletonList(fn));
+        while (as instanceof MappingIterable) {
+            MappingIterable<?, ?> nested = (MappingIterable<?, ?>) as;
+            as = (Iterable) nested.as;
+            mappers.addAll(0, nested.mappers);
+        }
+        this.as = as;
+        this.mappers = mappers;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Iterator<B> iterator() {
+        Function fnComposedOnTheHeap = o -> foldLeft((x, fn) -> fn.apply(x), o, mappers);
+        return new MappingIterator<>(fnComposedOnTheHeap, as.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/MappingIterator.java
similarity index 92%
rename from src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/MappingIterator.java
index 81b46c027..82624603f 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/MappingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.function.Function;
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterable.java
new file mode 100644
index 000000000..e4b2ca429
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterable.java
@@ -0,0 +1,32 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Any.any;
+import static java.util.Collections.singletonList;
+
+public final class PredicatedDroppingIterable<A> implements Iterable<A> {
+    private final List<Function<? super A, Boolean>> predicates;
+    private final Iterable<A>                        as;
+
+    public PredicatedDroppingIterable(Function<? super A, Boolean> predicate, Iterable<A> as) {
+        List<Function<? super A, Boolean>> predicates = new ArrayList<>(singletonList(predicate));
+
+        while (as instanceof PredicatedDroppingIterable) {
+            PredicatedDroppingIterable<A> nested = (PredicatedDroppingIterable<A>) as;
+            as = nested.as;
+            predicates.addAll(nested.predicates);
+        }
+        this.predicates = predicates;
+        this.as = as;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        Function<? super A, Boolean> metaPredicate = a -> any(p -> p.apply(a), predicates);
+        return new PredicatedDroppingIterator<>(metaPredicate, as.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterator.java
similarity index 96%
rename from src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterator.java
index c7f8f279e..e94b97d5d 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterable.java
new file mode 100644
index 000000000..4c80ccdb8
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterable.java
@@ -0,0 +1,31 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.All.all;
+import static java.util.Collections.singletonList;
+
+public final class PredicatedTakingIterable<A> implements Iterable<A> {
+    private final List<Function<? super A, Boolean>> predicates;
+    private final Iterable<A>                        as;
+
+    public PredicatedTakingIterable(Function<? super A, Boolean> predicate, Iterable<A> as) {
+        List<Function<? super A, Boolean>> predicates = new ArrayList<>(singletonList(predicate));
+        while (as instanceof PredicatedTakingIterable) {
+            PredicatedTakingIterable<A> nested = (PredicatedTakingIterable<A>) as;
+            as = nested.as;
+            predicates.addAll(nested.predicates);
+        }
+        this.predicates = predicates;
+        this.as = as;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        Function<? super A, Boolean> metaPredicate = a -> all(p -> p.apply(a), predicates);
+        return new PredicatedTakingIterator<>(metaPredicate, as.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterator.java
similarity index 96%
rename from src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterator.java
index c269ad72b..a53684946 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/PrependingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/PrependingIterator.java
similarity index 94%
rename from src/main/java/com/jnape/palatable/lambda/iterators/PrependingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/PrependingIterator.java
index 3b3a75fde..53755c0f2 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/PrependingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/PrependingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/RepetitiousIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/RepetitiousIterator.java
similarity index 83%
rename from src/main/java/com/jnape/palatable/lambda/iterators/RepetitiousIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/RepetitiousIterator.java
index da3c73cbe..7f43bed68 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/RepetitiousIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/RepetitiousIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 public class RepetitiousIterator<A> extends InfiniteIterator<A> {
 
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterable.java
new file mode 100644
index 000000000..df4c25e45
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterable.java
@@ -0,0 +1,24 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Iterator;
+
+public final class ReversingIterable<A> implements Iterable<A> {
+    private final Iterable<A> as;
+    private final boolean     reverse;
+
+    public ReversingIterable(Iterable<A> as) {
+        boolean reverse = true;
+        while (as instanceof ReversingIterable) {
+            ReversingIterable<A> nested = (ReversingIterable<A>) as;
+            as = nested.as;
+            reverse = !nested.reverse;
+        }
+        this.as = as;
+        this.reverse = reverse;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return reverse ? new ReversingIterator<>(as.iterator()) : as.iterator();
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ReversingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterator.java
similarity index 95%
rename from src/main/java/com/jnape/palatable/lambda/iterators/ReversingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterator.java
index fd042ee9a..e676cfa11 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ReversingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ReversingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.ArrayList;
 import java.util.Iterator;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/RewindableIterator.java
similarity index 97%
rename from src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/RewindableIterator.java
index 99f96cb6a..07b540704 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/RewindableIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/ScanningIterator.java
similarity index 95%
rename from src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/ScanningIterator.java
index aaaa43fb7..d195b14b3 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ScanningIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/SnocIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/SnocIterable.java
new file mode 100644
index 000000000..a16947b4a
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/SnocIterable.java
@@ -0,0 +1,28 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Collections;
+import java.util.Iterator;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Cons.cons;
+import static com.jnape.palatable.lambda.monoid.builtin.Concat.concat;
+
+public final class SnocIterable<A> implements Iterable<A> {
+    private final Iterable<A> as;
+    private final Iterable<A> snocs;
+
+    public SnocIterable(A a, Iterable<A> as) {
+        Iterable<A> snocs = cons(a, Collections::emptyIterator);
+        while (as instanceof SnocIterable) {
+            SnocIterable<A> nested = ((SnocIterable<A>) as);
+            as = nested.as;
+            snocs = concat(nested.snocs, snocs);
+        }
+        this.as = as;
+        this.snocs = snocs;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return new SnocIterator<>(as.iterator(), snocs.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/SnocIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/SnocIterator.java
new file mode 100644
index 000000000..7c084c7ab
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/SnocIterator.java
@@ -0,0 +1,28 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public final class SnocIterator<A> implements Iterator<A> {
+
+    private final Iterator<A> as;
+    private final Iterator<A> snocs;
+
+    public SnocIterator(Iterator<A> as, Iterator<A> snocs) {
+        this.as = as;
+        this.snocs = snocs;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return as.hasNext() || snocs.hasNext();
+    }
+
+    @Override
+    public A next() {
+        if (!hasNext())
+            throw new NoSuchElementException();
+
+        return as.hasNext() ? as.next() : snocs.next();
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iteration/TakingIterable.java b/src/main/java/com/jnape/palatable/lambda/iteration/TakingIterable.java
new file mode 100644
index 000000000..ce67f8e89
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/TakingIterable.java
@@ -0,0 +1,25 @@
+package com.jnape.palatable.lambda.iteration;
+
+import java.util.Iterator;
+
+import static java.lang.Math.min;
+
+public final class TakingIterable<A> implements Iterable<A> {
+    private final int         n;
+    private final Iterable<A> as;
+
+    public TakingIterable(int n, Iterable<A> as) {
+        while (as instanceof TakingIterable) {
+            TakingIterable<A> nested = (TakingIterable<A>) as;
+            n = min(n, nested.n);
+            as = nested.as;
+        }
+        this.n = n;
+        this.as = as;
+    }
+
+    @Override
+    public Iterator<A> iterator() {
+        return new TakingIterator<>(n, as.iterator());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/TakingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/TakingIterator.java
similarity index 93%
rename from src/main/java/com/jnape/palatable/lambda/iterators/TakingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/TakingIterator.java
index 8e659dc68..6cfedc82b 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/TakingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/TakingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/UnfoldingIterator.java
similarity index 77%
rename from src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/UnfoldingIterator.java
index a5fcfcc42..2c8790f1d 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/UnfoldingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import com.jnape.palatable.lambda.adt.Maybe;
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
@@ -10,15 +10,19 @@
 
 public class UnfoldingIterator<A, B> extends ImmutableIterator<A> {
     private final Function<? super B, Maybe<Tuple2<A, B>>> function;
+    private       B                                        seed;
     private       Maybe<Tuple2<A, B>>                      maybeAcc;
 
-    public UnfoldingIterator(Function<? super B, Maybe<Tuple2<A, B>>> function, B b) {
+    public UnfoldingIterator(Function<? super B, Maybe<Tuple2<A, B>>> function, B seed) {
         this.function = function;
-        maybeAcc = function.apply(b);
+        this.seed = seed;
     }
 
     @Override
     public boolean hasNext() {
+        if (maybeAcc == null)
+            maybeAcc = function.apply(seed);
+
         return maybeAcc.fmap(constantly(true)).orElse(false);
     }
 
@@ -30,7 +34,8 @@ public A next() {
 
         Tuple2<A, B> acc = maybeAcc.orElseThrow(NoSuchElementException::new);
         A next = acc._1();
-        maybeAcc = function.apply(acc._2());
+        seed = acc._2();
+        maybeAcc = null;
         return next;
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java b/src/main/java/com/jnape/palatable/lambda/iteration/ZippingIterator.java
similarity index 94%
rename from src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java
rename to src/main/java/com/jnape/palatable/lambda/iteration/ZippingIterator.java
index 0372e6fff..147079e80 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iteration/ZippingIterator.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import java.util.Iterator;
 import java.util.function.BiFunction;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ConcatenatingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/ConcatenatingIterator.java
deleted file mode 100644
index cd58f6f74..000000000
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ConcatenatingIterator.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package com.jnape.palatable.lambda.iterators;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Supplier;
-
-public class ConcatenatingIterator<A> implements Iterator<A> {
-
-    private final Supplier<Iterator<A>>        xsSupplier;
-    private final Supplier<Iterator<A>>        ysSupplier;
-    private final AtomicReference<Iterator<A>> xsRef;
-    private final AtomicReference<Iterator<A>> ysRef;
-    private       boolean                      iteratedXs;
-
-    public ConcatenatingIterator(Iterable<A> xs, Iterable<A> ys) {
-        xsSupplier = xs::iterator;
-        ysSupplier = ys::iterator;
-        xsRef = new AtomicReference<>();
-        ysRef = new AtomicReference<>();
-        iteratedXs = false;
-    }
-
-    @Override
-    public boolean hasNext() {
-        if (hasNext(xsRef, xsSupplier))
-            return true;
-
-        iteratedXs = true;
-        return hasNext(ysRef, ysSupplier);
-    }
-
-    private boolean hasNext(AtomicReference<Iterator<A>> ref, Supplier<Iterator<A>> supplier) {
-        Iterator<A> as = ref.updateAndGet(it -> it == null ? supplier.get() : it);
-        while (as instanceof ConcatenatingIterator && ((ConcatenatingIterator<A>) as).iteratedXs)
-            as = ref.updateAndGet(it -> ((ConcatenatingIterator<A>) it).ysRef.get());
-        return as.hasNext();
-    }
-
-    @Override
-    public A next() {
-        if (!hasNext())
-            throw new NoSuchElementException();
-
-        return !iteratedXs ? xsRef.get().next() : ysRef.get().next();
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/SnocIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/SnocIterator.java
deleted file mode 100644
index 2506bd658..000000000
--- a/src/main/java/com/jnape/palatable/lambda/iterators/SnocIterator.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package com.jnape.palatable.lambda.iterators;
-
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-import java.util.function.Supplier;
-
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Cons.cons;
-
-public final class SnocIterator<A> implements Iterator<A> {
-
-    private final Supplier<Iterator<A>> initsSupplier;
-    private final A                     last;
-    private       Iterator<A>           inits;
-    private       Iterator<A>           lasts;
-
-    public SnocIterator(A last, Iterable<A> inits) {
-        this.last = last;
-        initsSupplier = inits::iterator;
-    }
-
-    @Override
-    public boolean hasNext() {
-        if (inits == null)
-            queueAndDeforest();
-
-        return inits.hasNext() || lasts.hasNext();
-    }
-
-    @Override
-    public A next() {
-        if (!hasNext())
-            throw new NoSuchElementException();
-
-        return inits.hasNext() ? inits.next() : lasts.next();
-    }
-
-    private void queueAndDeforest() {
-        Iterable<A> lastConses = Collections::emptyIterator;
-        inits = this;
-        while (inits instanceof SnocIterator) {
-            SnocIterator<A> it = (SnocIterator<A>) inits;
-            lastConses = cons(it.last, lastConses);
-            inits = it.initsSupplier.get();
-        }
-        lasts = lastConses.iterator();
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/Iso.java b/src/main/java/com/jnape/palatable/lambda/lens/Iso.java
new file mode 100644
index 000000000..56caf718e
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/lens/Iso.java
@@ -0,0 +1,298 @@
+package com.jnape.palatable.lambda.lens;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.functor.Functor;
+import com.jnape.palatable.lambda.functor.Profunctor;
+import com.jnape.palatable.lambda.functor.builtin.Exchange;
+import com.jnape.palatable.lambda.functor.builtin.Identity;
+import com.jnape.palatable.lambda.lens.functions.Over;
+import com.jnape.palatable.lambda.lens.functions.Set;
+import com.jnape.palatable.lambda.lens.functions.View;
+import com.jnape.palatable.lambda.monad.Monad;
+
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.Fn1.fn1;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.lens.Iso.Simple.adapt;
+import static com.jnape.palatable.lambda.lens.functions.View.view;
+
+/**
+ * An {@link Iso} (short for "isomorphism") is an invertible {@link Lens}: a {@link LensLike} encoding of a
+ * bi-directional focusing of two types, and like <code>{@link Lens}es</code>, can be <code>{@link View}ed</code>,
+ * {@link Set}, and <code>{@link Over}ed</code>.
+ * <p>
+ * As an example, consider the isomorphism between valid {@link String}s and {@link Integer}s:
+ * <pre>
+ * {@code
+ * Iso<String, String, Integer, Integer> stringIntIso = Iso.iso(Integer::parseInt, Object::toString);
+ * Integer asInt = view(stringIntIso, "123"); // 123
+ * String asString = view(stringIntIso.mirror(), 123); // "123"
+ * }
+ * </pre>
+ * In the previous example, <code>stringIntIso</code> can be viewed as a <code>{@link Lens}&lt;String, String, Integer,
+ * Integer&gt;</code>, and can be <code>{@link Iso#mirror}ed</code> and viewed as a <code>{@link Lens}&lt;Integer,
+ * Integer, String, String&gt;</code>.
+ * <p>
+ * As with {@link Lens}, variance is supported between <code>S/T</code> and <code>A/B</code>, and where these pairs do
+ * not vary, a {@link Simple} iso can be used (for instance, in the previous example, <code>stringIntIso</code> could
+ * have had the simplified <code>Iso.Simple&lt;String, Integer&gt;</code> type).
+ * <p>
+ * For more information, read about <a href="https://hackage.haskell.org/package/lens-4.16.1/docs/Control-Lens-Iso.html">isos</a>.
+ *
+ * @param <S> the larger type for focusing
+ * @param <T> the larger type for mirrored focusing
+ * @param <A> the smaller type for focusing
+ * @param <B> the smaller type for mirrored focusing
+ */
+@FunctionalInterface
+public interface Iso<S, T, A, B> extends LensLike<S, T, A, B, Iso> {
+
+    <P extends Profunctor, F extends Functor, FB extends Functor<B, F>, FT extends Functor<T, F>,
+            PAFB extends Profunctor<A, FB, P>,
+            PSFT extends Profunctor<S, FT, P>> PSFT apply(PAFB pafb);
+
+    @Override
+    default <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> FT apply(
+            Function<? super A, ? extends FB> fn, S s) {
+        return this.<Fn1, F, FB, FT, Fn1<A, FB>, Fn1<S, FT>>apply(fn1(fn)).apply(s);
+    }
+
+    /**
+     * Convert this {@link Iso} into a {@link Lens}.
+     *
+     * @return the equivalent lens
+     */
+    default Lens<S, T, A, B> toLens() {
+        return new Lens<S, T, A, B>() {
+            @Override
+            public <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> FT apply(
+                    Function<? super A, ? extends FB> fn, S s) {
+                return Iso.this.apply(fn, s);
+            }
+        };
+    }
+
+    /**
+     * Flip this {@link Iso} around.
+     *
+     * @return the mirrored {@link Iso}
+     */
+    default Iso<B, A, T, S> mirror() {
+        return unIso().into((sa, bt) -> iso(bt, sa));
+    }
+
+    /**
+     * Destructure this {@link Iso} into the two functions <code>S -&lt; A</code> and <code>B -&lt; T</code> that
+     * constitute the isomorphism.
+     *
+     * @return the destructured iso
+     */
+    default Tuple2<Fn1<? super S, ? extends A>, Fn1<? super B, ? extends T>> unIso() {
+        return Tuple2.fill(this.<Exchange<A, B, ?, ?>, Identity, Identity<B>, Identity<T>,
+                Exchange<A, B, A, Identity<B>>,
+                Exchange<A, B, S, Identity<T>>>apply(new Exchange<>(id(), Identity::new)).diMapR(Identity::runIdentity))
+                .biMap(e -> fn1(e.sa()), e -> fn1(e.bt()));
+    }
+
+    @Override
+    default <U> Iso<S, U, A, B> fmap(Function<? super T, ? extends U> fn) {
+        return LensLike.super.<U>fmap(fn).coerce();
+    }
+
+    @Override
+    default <U> Iso<S, U, A, B> pure(U u) {
+        return iso(view(this), constantly(u));
+    }
+
+    @Override
+    default <U> Iso<S, U, A, B> zip(Applicative<Function<? super T, ? extends U>, LensLike<S, ?, A, B, Iso>> appFn) {
+        return LensLike.super.zip(appFn).coerce();
+    }
+
+    @Override
+    default <U> Iso<S, U, A, B> discardL(Applicative<U, LensLike<S, ?, A, B, Iso>> appB) {
+        return LensLike.super.discardL(appB).coerce();
+    }
+
+    @Override
+    default <U> Iso<S, T, A, B> discardR(Applicative<U, LensLike<S, ?, A, B, Iso>> appB) {
+        return LensLike.super.discardR(appB).coerce();
+    }
+
+    @Override
+    default <U> Iso<S, U, A, B> flatMap(Function<? super T, ? extends Monad<U, LensLike<S, ?, A, B, Iso>>> fn) {
+        return unIso().fmap(bt -> Fn2.<B, B, U>fn2(fn1(bt.andThen(fn.<Iso<S, U, A, B>>andThen(Applicative::coerce))
+                                                               .andThen(Iso::unIso)
+                                                               .andThen(Tuple2::_2)
+                                                               .andThen(Fn1::fn1))))
+                .fmap(Fn2::uncurry)
+                .fmap(bbu -> bbu.<B>diMapL(Tuple2::fill))
+                .into(Iso::iso);
+    }
+
+    @Override
+    default <R> Iso<R, T, A, B> diMapL(Function<? super R, ? extends S> fn) {
+        return LensLike.super.<R>diMapL(fn).coerce();
+    }
+
+    @Override
+    default <U> Iso<S, U, A, B> diMapR(Function<? super T, ? extends U> fn) {
+        return LensLike.super.<U>diMapR(fn).coerce();
+    }
+
+    @Override
+    default <R, U> Iso<R, U, A, B> diMap(Function<? super R, ? extends S> lFn,
+                                         Function<? super T, ? extends U> rFn) {
+        return LensLike.super.<R, U>diMap(lFn, rFn).coerce();
+    }
+
+    @Override
+    default <R> Iso<R, T, A, B> contraMap(Function<? super R, ? extends S> fn) {
+        return LensLike.super.<R>contraMap(fn).coerce();
+    }
+
+    @Override
+    default <R> Iso<R, T, A, B> mapS(Function<? super R, ? extends S> fn) {
+        return unIso().biMapL(f -> f.compose(fn)).into(Iso::iso);
+    }
+
+    @Override
+    default <U> Iso<S, U, A, B> mapT(Function<? super T, ? extends U> fn) {
+        return unIso().biMapR(f -> f.andThen(fn)).into(Iso::iso);
+    }
+
+    @Override
+    default <C> Iso<S, T, C, B> mapA(Function<? super A, ? extends C> fn) {
+        return unIso().biMapL(f -> f.andThen(fn)).into(Iso::iso);
+    }
+
+    @Override
+    default <Z> Iso<S, T, A, Z> mapB(Function<? super Z, ? extends B> fn) {
+        return unIso().biMapR(f -> f.compose(fn)).into(Iso::iso);
+    }
+
+    /**
+     * Left-to-right composition of {@link Iso}.
+     *
+     * @param f   the iso to apply after this one
+     * @param <C> the smaller type the first larger type can be viewed as
+     * @param <D> the smaller type that can be viewed as the second larger type
+     * @return the composed {@link Iso}
+     */
+    default <C, D> Iso<S, T, C, D> andThen(Iso<A, B, C, D> f) {
+        return unIso().into((sa, bt) -> f.unIso().into((ac, db) -> iso(sa.andThen(ac), db.andThen(bt))));
+    }
+
+    /**
+     * Right-to-left composition of {@link Iso}.
+     *
+     * @param g   the iso to apply before this one
+     * @param <Q> the larger type that can be viewed as the first smaller type
+     * @param <R> the larger type the second smaller type can be viewed as
+     * @return the composed {@link Iso}
+     */
+    default <Q, R> Iso<Q, R, A, B> compose(Iso<Q, R, S, T> g) {
+        return g.andThen(this);
+    }
+
+    /**
+     * Static factory method for creating an iso from a function and it's inverse.
+     *
+     * @param f   the function
+     * @param g   f's inverse
+     * @param <S> the larger type for focusing
+     * @param <T> the larger type for mirrored focusing
+     * @param <A> the smaller type for focusing
+     * @param <B> the smaller type for mirrored focusing
+     * @return the iso
+     */
+    static <S, T, A, B> Iso<S, T, A, B> iso(Function<? super S, ? extends A> f,
+                                            Function<? super B, ? extends T> g) {
+        return new Iso<S, T, A, B>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public <P extends Profunctor, F extends Functor, FB extends Functor<B, F>, FT extends Functor<T, F>, PAFB extends Profunctor<A, FB, P>, PSFT extends Profunctor<S, FT, P>> PSFT apply(
+                    PAFB pafb) {
+                return (PSFT) pafb.<S, FT>diMap(f, fb -> (FT) fb.<T>fmap(g));
+            }
+        };
+    }
+
+    /**
+     * Static factory method for creating a simple {@link Iso} from a function and its inverse.
+     *
+     * @param f   a function
+     * @param g   f's inverse
+     * @param <S> one side of the isomorphism
+     * @param <A> the other side of the isomorphism
+     * @return the simple iso
+     */
+    static <S, A> Iso.Simple<S, A> simpleIso(Function<? super S, ? extends A> f, Function<? super A, ? extends S> g) {
+        return adapt(iso(f, g));
+    }
+
+    /**
+     * A convenience type with a simplified type signature for common isos with both unified "larger" values and
+     * unified "smaller" values.
+     *
+     * @param <S> the type of both "larger" values
+     * @param <A> the type of both "smaller" values
+     */
+    interface Simple<S, A> extends Iso<S, S, A, A>, LensLike.Simple<S, A, Iso> {
+
+        @Override
+        default Iso.Simple<A, S> mirror() {
+            return adapt(Iso.super.mirror());
+        }
+
+        @Override
+        default Lens.Simple<S, A> toLens() {
+            return Lens.Simple.adapt(Iso.super.toLens());
+        }
+
+        @Override
+        default <U> Iso.Simple<S, A> discardR(Applicative<U, LensLike<S, ?, A, A, Iso>> appB) {
+            return adapt(Iso.super.discardR(appB));
+        }
+
+        /**
+         * Compose two simple isos from right to left.
+         *
+         * @param g   the other simple iso
+         * @param <R> the other simple iso' larger type
+         * @return the composed simple iso
+         */
+        default <R> Iso.Simple<R, A> compose(Iso.Simple<R, S> g) {
+            return Iso.Simple.adapt(Iso.super.compose(g));
+        }
+
+        /**
+         * Compose two simple isos from left to right.
+         *
+         * @param f   the other simple iso
+         * @param <B> the other simple iso' smaller type
+         * @return the composed simple iso
+         */
+        default <B> Iso.Simple<S, B> andThen(Iso.Simple<A, B> f) {
+            return adapt(f.compose(this));
+        }
+
+        /**
+         * Adapt an {@link Iso} with the right variance to an {@link Iso.Simple}.
+         *
+         * @param iso the iso
+         * @param <S> S/T
+         * @param <A> A/B
+         * @return the simple iso
+         */
+        @SuppressWarnings("unchecked")
+        static <S, A> Iso.Simple<S, A> adapt(Iso<S, S, A, A> iso) {
+            return iso::apply;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/Lens.java b/src/main/java/com/jnape/palatable/lambda/lens/Lens.java
index 7042b603d..9b0f54774 100644
--- a/src/main/java/com/jnape/palatable/lambda/lens/Lens.java
+++ b/src/main/java/com/jnape/palatable/lambda/lens/Lens.java
@@ -1,15 +1,15 @@
 package com.jnape.palatable.lambda.lens;
 
-import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.builtin.fn2.Both;
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Functor;
-import com.jnape.palatable.lambda.functor.Profunctor;
 import com.jnape.palatable.lambda.monad.Monad;
 
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 import static com.jnape.palatable.lambda.lens.Lens.Simple.adapt;
 import static com.jnape.palatable.lambda.lens.functions.Over.over;
 import static com.jnape.palatable.lambda.lens.functions.Set.set;
@@ -136,29 +136,11 @@
  * @param <B> the type of the "smaller" update value
  */
 @FunctionalInterface
-public interface Lens<S, T, A, B> extends Monad<T, Lens<S, ?, A, B>>, Profunctor<S, T, Lens<?, ?, A, B>> {
-
-    <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> FT apply(
-            Function<? super A, ? extends FB> fn, S s);
-
-    /**
-     * Fix this lens against some functor, producing a non-polymorphic runnable lens as an {@link Fn2}.
-     * <p>
-     * Although the Java type system does not allow enforceability, the functor instance FT should be the same as FB,
-     * only differentiating in their parameters.
-     *
-     * @param <F>  the common functor type of FT and FB
-     * @param <FT> the type of the lifted T
-     * @param <FB> the type of the lifted B
-     * @return the lens, "fixed" to the functor
-     */
-    default <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> Fixed<S, T, A, B, F, FT, FB> fix() {
-        return this::apply;
-    }
+public interface Lens<S, T, A, B> extends LensLike<S, T, A, B, Lens> {
 
     @Override
     default <U> Lens<S, U, A, B> fmap(Function<? super T, ? extends U> fn) {
-        return Monad.super.<U>fmap(fn).coerce();
+        return LensLike.super.<U>fmap(fn).coerce();
     }
 
     @Override
@@ -167,87 +149,64 @@ default <U> Lens<S, U, A, B> pure(U u) {
     }
 
     @Override
-    default <U> Lens<S, U, A, B> zip(Applicative<Function<? super T, ? extends U>, Lens<S, ?, A, B>> appFn) {
-        return Monad.super.zip(appFn).coerce();
+    default <U> Lens<S, U, A, B> zip(Applicative<Function<? super T, ? extends U>, LensLike<S, ?, A, B, Lens>> appFn) {
+        return LensLike.super.zip(appFn).coerce();
     }
 
     @Override
-    default <U> Lens<S, U, A, B> discardL(Applicative<U, Lens<S, ?, A, B>> appB) {
-        return Monad.super.discardL(appB).coerce();
+    default <U> Lens<S, U, A, B> discardL(Applicative<U, LensLike<S, ?, A, B, Lens>> appB) {
+        return LensLike.super.discardL(appB).coerce();
     }
 
     @Override
-    default <U> Lens<S, T, A, B> discardR(Applicative<U, Lens<S, ?, A, B>> appB) {
-        return Monad.super.discardR(appB).coerce();
+    default <U> Lens<S, T, A, B> discardR(Applicative<U, LensLike<S, ?, A, B, Lens>> appB) {
+        return LensLike.super.discardR(appB).coerce();
     }
 
     @Override
-    default <U> Lens<S, U, A, B> flatMap(Function<? super T, ? extends Monad<U, Lens<S, ?, A, B>>> f) {
+    default <U> Lens<S, U, A, B> flatMap(Function<? super T, ? extends Monad<U, LensLike<S, ?, A, B, Lens>>> f) {
         return lens(view(this), (s, b) -> set(f.apply(set(this, b, s)).<Lens<S, U, A, B>>coerce(), b, s));
     }
 
     @Override
     default <R> Lens<R, T, A, B> diMapL(Function<? super R, ? extends S> fn) {
-        return (Lens<R, T, A, B>) Profunctor.super.<R>diMapL(fn);
+        return LensLike.super.<R>diMapL(fn).coerce();
     }
 
     @Override
     default <U> Lens<S, U, A, B> diMapR(Function<? super T, ? extends U> fn) {
-        return (Lens<S, U, A, B>) Profunctor.super.<U>diMapR(fn);
+        return LensLike.super.<U>diMapR(fn).coerce();
     }
 
     @Override
-    default <R, U> Lens<R, U, A, B> diMap(Function<? super R, ? extends S> lFn, Function<? super T, ? extends U> rFn) {
-        return this.<R>mapS(lFn).mapT(rFn);
+    default <R, U> Lens<R, U, A, B> diMap(Function<? super R, ? extends S> lFn,
+                                          Function<? super T, ? extends U> rFn) {
+        return LensLike.super.<R, U>diMap(lFn, rFn).coerce();
     }
 
     @Override
     default <R> Lens<R, T, A, B> contraMap(Function<? super R, ? extends S> fn) {
-        return (Lens<R, T, A, B>) Profunctor.super.<R>contraMap(fn);
+        return LensLike.super.<R>contraMap(fn).coerce();
     }
 
-    /**
-     * Contravariantly map <code>S</code> to <code>R</code>, yielding a new lens.
-     *
-     * @param fn  the mapping function
-     * @param <R> the type of the new "larger" value for reading
-     * @return the new lens
-     */
+    @Override
     default <R> Lens<R, T, A, B> mapS(Function<? super R, ? extends S> fn) {
-        return compose(lens(fn, (r, t) -> t));
+        return lens(view(this).compose(fn), (r, b) -> set(this, b, fn.apply(r)));
     }
 
-    /**
-     * Covariantly map <code>T</code> to <code>U</code>, yielding a new lens.
-     *
-     * @param fn  the mapping function
-     * @param <U> the type of the new "larger" value for putting
-     * @return the new lens
-     */
+    @Override
     default <U> Lens<S, U, A, B> mapT(Function<? super T, ? extends U> fn) {
         return fmap(fn);
     }
 
-    /**
-     * Covariantly map <code>A</code> to <code>C</code>, yielding a new lens.
-     *
-     * @param fn  the mapping function
-     * @param <C> the type of the new "smaller" value that is read
-     * @return the new lens
-     */
+    @Override
     default <C> Lens<S, T, C, B> mapA(Function<? super A, ? extends C> fn) {
         return andThen(lens(fn, (a, b) -> b));
     }
 
-    /**
-     * Contravariantly map <code>B</code> to <code>Z</code>, yielding a new lens.
-     *
-     * @param fn  the mapping function
-     * @param <Z> the type of the new "smaller" update value
-     * @return the new lens
-     */
+    @Override
     default <Z> Lens<S, T, A, Z> mapB(Function<? super Z, ? extends B> fn) {
-        return andThen(lens(id(), (a, z) -> fn.apply(z)));
+        return lens(view(this), (s, z) -> set(this, fn.apply(z), s));
     }
 
     /**
@@ -312,6 +271,37 @@ static <S, A> Lens.Simple<S, A> simpleLens(Function<? super S, ? extends A> gett
         return adapt(lens(getter, setter));
     }
 
+    /**
+     * Dually focus on two lenses at the same time. Requires <code>S</code> and <code>T</code> to be invariant between
+     * lenses.
+     *
+     * @param f   the first lens
+     * @param g   the second lens
+     * @param <S> both larger values
+     * @param <A> f's smaller viewing value
+     * @param <B> g's smaller viewing value
+     * @param <C> f's smaller setting value
+     * @param <D> g's smaller setting value
+     * @return the dual-focus lens
+     */
+    static <S, A, B, C, D> Lens<S, S, Tuple2<A, B>, Tuple2<C, D>> both(Lens<S, S, A, C> f, Lens<S, S, B, D> g) {
+        return lens(Both.both(view(f), view(g)), (s, cd) -> cd.biMap(set(f), set(g)).into(Fn1::compose).apply(s));
+    }
+
+    /**
+     * Dually focus on two simple lenses at the same time.
+     *
+     * @param f   the first lens
+     * @param g   the second lens
+     * @param <S> both larger values
+     * @param <A> both smaller viewing values
+     * @param <B> both smaller setting values
+     * @return the dual-focus simple lens
+     */
+    static <S, A, B> Lens.Simple<S, Tuple2<A, B>> both(Lens.Simple<S, A> f, Lens.Simple<S, B> g) {
+        return adapt(both((Lens<S, S, A, A>) f, g));
+    }
+
     /**
      * A convenience type with a simplified type signature for common lenses with both unified "larger" values and
      * unified "smaller" values.
@@ -320,55 +310,55 @@ static <S, A> Lens.Simple<S, A> simpleLens(Function<? super S, ? extends A> gett
      * @param <A> the type of both "smaller" values
      */
     @FunctionalInterface
-    interface Simple<S, A> extends Lens<S, S, A, A> {
+    interface Simple<S, A> extends Lens<S, S, A, A>, LensLike.Simple<S, A, Lens> {
 
-        @Override
-        default <F extends Functor, FS extends Functor<S, F>, FA extends Functor<A, F>> Fixed<S, A, F, FS, FA> fix() {
-            return this::apply;
-        }
-
-        @SuppressWarnings("unchecked")
+        /**
+         * Compose two simple lenses from right to left.
+         *
+         * @param g   the other simple lens
+         * @param <R> the other simple lens' larger type
+         * @return the composed simple lens
+         */
         default <R> Lens.Simple<R, A> compose(Lens.Simple<R, S> g) {
-            return Lens.super.compose(g)::apply;
+            return Lens.Simple.adapt(Lens.super.compose(g));
         }
 
+        /**
+         * Compose two simple lenses from left to right.
+         *
+         * @param f   the other simple lens
+         * @param <B> the other simple lens' smaller type
+         * @return the composed simple lens
+         */
         default <B> Lens.Simple<S, B> andThen(Lens.Simple<A, B> f) {
             return f.compose(this);
         }
 
+        /**
+         * Adapt a {@link Lens} with the right variance to a {@link Lens.Simple}.
+         *
+         * @param lens the lens
+         * @param <S>  S/T
+         * @param <A>  A/B
+         * @return the simple lens
+         */
         @SuppressWarnings("unchecked")
-        static <S, A> Simple<S, A> adapt(Lens<S, S, A, A> lens) {
+        static <S, A> Lens.Simple<S, A> adapt(Lens<S, S, A, A> lens) {
             return lens::apply;
         }
 
         /**
-         * A convenience type with a simplified type signature for fixed simple lenses.
+         * Specialization of {@link Lens#both(Lens, Lens)} for simple lenses.
          *
-         * @param <S>  the type of both "larger" values
-         * @param <A>  the type of both "smaller" values
-         * @param <FS> the type of the lifted s
-         * @param <FA> the type of the lifted A
+         * @param f   the first lens
+         * @param g   the second lens
+         * @param <S> both lens larger values
+         * @param <A> lens f smaller values
+         * @param <B> lens g smaller values
+         * @return the dual-focus simple lens
          */
-        @FunctionalInterface
-        interface Fixed<S, A, F extends Functor, FS extends Functor<S, F>, FA extends Functor<A, F>>
-                extends Lens.Fixed<S, S, A, A, F, FS, FA> {
+        static <S, A, B> Lens.Simple<S, Tuple2<A, B>> both(Lens<S, S, A, A> f, Lens<S, S, B, B> g) {
+            return Lens.Simple.adapt(Lens.both(f, g));
         }
     }
-
-    /**
-     * A lens that has been fixed to a functor. Because the lens is no longer polymorphic, it can additionally be safely
-     * represented as an Fn2.
-     *
-     * @param <S>  the type of the "larger" value for reading
-     * @param <T>  the type of the "larger" value for putting
-     * @param <A>  the type of the "smaller" value that is read
-     * @param <B>  the type of the "smaller" update value
-     * @param <F>  the functor unification type between FT and FB
-     * @param <FT> the type of the lifted T
-     * @param <FB> the type of the lifted B
-     */
-    @FunctionalInterface
-    interface Fixed<S, T, A, B, F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>>
-            extends Fn2<Function<? super A, ? extends FB>, S, FT> {
-    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/LensLike.java b/src/main/java/com/jnape/palatable/lambda/lens/LensLike.java
new file mode 100644
index 000000000..7b8b699f6
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/lens/LensLike.java
@@ -0,0 +1,121 @@
+package com.jnape.palatable.lambda.lens;
+
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.functor.Functor;
+import com.jnape.palatable.lambda.functor.Profunctor;
+import com.jnape.palatable.lambda.monad.Monad;
+
+import java.util.function.Function;
+
+/**
+ * The generic supertype of all types that can be treated as lenses but should preserve type-specific return types in
+ * overrides. This type only exists to appease Java's unfortunate parametric type hierarchy constraints. If you're here,
+ * you're probably looking for {@link Lens} or {@link Iso}.
+ *
+ * @param <S>  the type of the "larger" value for reading
+ * @param <T>  the type of the "larger" value for putting
+ * @param <A>  the type of the "smaller" value that is read
+ * @param <B>  the type of the "smaller" update value
+ * @param <LL> the concrete lens subtype
+ * @see Lens
+ * @see Iso
+ */
+public interface LensLike<S, T, A, B, LL extends LensLike> extends Monad<T, LensLike<S, ?, A, B, LL>>, Profunctor<S, T, LensLike<?, ?, A, B, LL>> {
+
+    <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> FT apply(
+            Function<? super A, ? extends FB> fn, S s);
+
+    /**
+     * Contravariantly map <code>S</code> to <code>R</code>, yielding a new lens.
+     *
+     * @param fn  the mapping function
+     * @param <R> the type of the new "larger" value for reading
+     * @return the new lens
+     */
+    <R> LensLike<R, T, A, B, LL> mapS(Function<? super R, ? extends S> fn);
+
+    /**
+     * Covariantly map <code>T</code> to <code>U</code>, yielding a new lens.
+     *
+     * @param fn  the mapping function
+     * @param <U> the type of the new "larger" value for putting
+     * @return the new lens
+     */
+    <U> LensLike<S, U, A, B, LL> mapT(Function<? super T, ? extends U> fn);
+
+    /**
+     * Covariantly map <code>A</code> to <code>C</code>, yielding a new lens.
+     *
+     * @param fn  the mapping function
+     * @param <C> the type of the new "smaller" value that is read
+     * @return the new lens
+     */
+    <C> LensLike<S, T, C, B, LL> mapA(Function<? super A, ? extends C> fn);
+
+    /**
+     * Contravariantly map <code>B</code> to <code>Z</code>, yielding a new lens.
+     *
+     * @param fn  the mapping function
+     * @param <Z> the type of the new "smaller" update value
+     * @return the new lens
+     */
+    <Z> LensLike<S, T, A, Z, LL> mapB(Function<? super Z, ? extends B> fn);
+
+    @Override
+    <U> LensLike<S, U, A, B, LL> flatMap(Function<? super T, ? extends Monad<U, LensLike<S, ?, A, B, LL>>> f);
+
+    @Override
+    <U> LensLike<S, U, A, B, LL> pure(U u);
+
+    @Override
+    default <U> LensLike<S, U, A, B, LL> fmap(Function<? super T, ? extends U> fn) {
+        return Monad.super.<U>fmap(fn).coerce();
+    }
+
+    @Override
+    default <U> LensLike<S, U, A, B, LL> zip(
+            Applicative<Function<? super T, ? extends U>, LensLike<S, ?, A, B, LL>> appFn) {
+        return Monad.super.zip(appFn).coerce();
+    }
+
+    @Override
+    default <U> LensLike<S, U, A, B, LL> discardL(Applicative<U, LensLike<S, ?, A, B, LL>> appB) {
+        return Monad.super.discardL(appB).coerce();
+    }
+
+    @Override
+    default <U> LensLike<S, T, A, B, LL> discardR(Applicative<U, LensLike<S, ?, A, B, LL>> appB) {
+        return Monad.super.discardR(appB).coerce();
+    }
+
+    @Override
+    default <R> LensLike<R, T, A, B, LL> diMapL(Function<? super R, ? extends S> fn) {
+        return (LensLike<R, T, A, B, LL>) Profunctor.super.<R>diMapL(fn);
+    }
+
+    @Override
+    default <U> LensLike<S, U, A, B, LL> diMapR(Function<? super T, ? extends U> fn) {
+        return (LensLike<S, U, A, B, LL>) Profunctor.super.<U>diMapR(fn);
+    }
+
+    @Override
+    default <R, U> LensLike<R, U, A, B, LL> diMap(Function<? super R, ? extends S> lFn,
+                                                  Function<? super T, ? extends U> rFn) {
+        return this.<R>mapS(lFn).mapT(rFn);
+    }
+
+    @Override
+    default <R> LensLike<R, T, A, B, LL> contraMap(Function<? super R, ? extends S> fn) {
+        return (LensLike<R, T, A, B, LL>) Profunctor.super.<R>contraMap(fn);
+    }
+
+    /**
+     * A simpler type signature for lenses where <code>S/T</code> and <code>A/B</code> are equivalent.
+     *
+     * @param <S>  the "larger" type
+     * @param <A>  the "smaller" type
+     * @param <LL> the concrete lens subtype
+     */
+    interface Simple<S, A, LL extends LensLike> extends LensLike<S, S, A, A, LL> {
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/functions/Over.java b/src/main/java/com/jnape/palatable/lambda/lens/functions/Over.java
index 131aa5046..5c1de0104 100644
--- a/src/main/java/com/jnape/palatable/lambda/lens/functions/Over.java
+++ b/src/main/java/com/jnape/palatable/lambda/lens/functions/Over.java
@@ -4,7 +4,7 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.Fn3;
 import com.jnape.palatable.lambda.functor.builtin.Identity;
-import com.jnape.palatable.lambda.lens.Lens;
+import com.jnape.palatable.lambda.lens.LensLike;
 
 import java.util.function.Function;
 
@@ -23,7 +23,7 @@
  * @see Set
  * @see View
  */
-public final class Over<S, T, A, B> implements Fn3<Lens<S, T, A, B>, Function<? super A, ? extends B>, S, T> {
+public final class Over<S, T, A, B> implements Fn3<LensLike<S, T, A, B, ?>, Function<? super A, ? extends B>, S, T> {
 
     private static final Over INSTANCE = new Over();
 
@@ -31,10 +31,8 @@ private Over() {
     }
 
     @Override
-    public T apply(Lens<S, T, A, B> lens, Function<? super A, ? extends B> fn, S s) {
-        return lens.<Identity, Identity<T>, Identity<B>>fix()
-                .apply(fn.andThen((Function<B, Identity<B>>) Identity::new), s)
-                .runIdentity();
+    public T apply(LensLike<S, T, A, B, ?> lens, Function<? super A, ? extends B> fn, S s) {
+        return lens.<Identity, Identity<T>, Identity<B>>apply(fn.andThen((Function<B, Identity<B>>) Identity::new), s).runIdentity();
     }
 
     @SuppressWarnings("unchecked")
@@ -42,17 +40,15 @@ public static <S, T, A, B> Over<S, T, A, B> over() {
         return (Over<S, T, A, B>) INSTANCE;
     }
 
-    public static <S, T, A, B> Fn2<Function<? super A, ? extends B>, S, T> over(
-            Lens<S, T, A, B> lens) {
+    public static <S, T, A, B> Fn2<Function<? super A, ? extends B>, S, T> over(LensLike<S, T, A, B, ?> lens) {
         return Over.<S, T, A, B>over().apply(lens);
     }
 
-    public static <S, T, A, B> Fn1<S, T> over(Lens<S, T, A, B> lens,
-                                              Function<? super A, ? extends B> fn) {
+    public static <S, T, A, B> Fn1<S, T> over(LensLike<S, T, A, B, ?> lens, Function<? super A, ? extends B> fn) {
         return over(lens).apply(fn);
     }
 
-    public static <S, T, A, B> T over(Lens<S, T, A, B> lens, Function<? super A, ? extends B> fn, S s) {
+    public static <S, T, A, B> T over(LensLike<S, T, A, B, ?> lens, Function<? super A, ? extends B> fn, S s) {
         return over(lens, fn).apply(s);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/functions/Set.java b/src/main/java/com/jnape/palatable/lambda/lens/functions/Set.java
index b3c5ff243..07c97b804 100644
--- a/src/main/java/com/jnape/palatable/lambda/lens/functions/Set.java
+++ b/src/main/java/com/jnape/palatable/lambda/lens/functions/Set.java
@@ -4,7 +4,7 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.Fn3;
 import com.jnape.palatable.lambda.functor.builtin.Identity;
-import com.jnape.palatable.lambda.lens.Lens;
+import com.jnape.palatable.lambda.lens.LensLike;
 
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 import static com.jnape.palatable.lambda.lens.functions.Over.over;
@@ -23,7 +23,7 @@
  * @see Over
  * @see View
  */
-public final class Set<S, T, A, B> implements Fn3<Lens<S, T, A, B>, B, S, T> {
+public final class Set<S, T, A, B> implements Fn3<LensLike<S, T, A, B, ?>, B, S, T> {
 
     private static final Set INSTANCE = new Set();
 
@@ -31,7 +31,7 @@ private Set() {
     }
 
     @Override
-    public T apply(Lens<S, T, A, B> lens, B b, S s) {
+    public T apply(LensLike<S, T, A, B, ?> lens, B b, S s) {
         return over(lens, constantly(b), s);
     }
 
@@ -40,15 +40,15 @@ public static <S, T, A, B> Set<S, T, A, B> set() {
         return INSTANCE;
     }
 
-    public static <S, T, A, B> Fn2<B, S, T> set(Lens<S, T, A, B> lens) {
+    public static <S, T, A, B> Fn2<B, S, T> set(LensLike<S, T, A, B, ?> lens) {
         return Set.<S, T, A, B>set().apply(lens);
     }
 
-    public static <S, T, A, B> Fn1<S, T> set(Lens<S, T, A, B> lens, B b) {
+    public static <S, T, A, B> Fn1<S, T> set(LensLike<S, T, A, B, ?> lens, B b) {
         return set(lens).apply(b);
     }
 
-    public static <S, T, A, B> T set(Lens<S, T, A, B> lens, B b, S s) {
+    public static <S, T, A, B> T set(LensLike<S, T, A, B, ?> lens, B b, S s) {
         return set(lens, b).apply(s);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/functions/Under.java b/src/main/java/com/jnape/palatable/lambda/lens/functions/Under.java
new file mode 100644
index 000000000..11c37a1e5
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/lens/functions/Under.java
@@ -0,0 +1,52 @@
+package com.jnape.palatable.lambda.lens.functions;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.functions.Fn3;
+import com.jnape.palatable.lambda.lens.Iso;
+import com.jnape.palatable.lambda.lens.LensLike;
+
+import java.util.function.Function;
+
+/**
+ * The inverse of {@link Over}: given an {@link Iso}, a function from <code>T</code> to <code>S</code>, and a "smaller"
+ * value <code>B</code>, return a "smaller" value <code>A</code> by traversing around the type ring (<code>B -&gt; T
+ * -&gt; S -&gt; A</code>).
+ * <p>
+ * Note this is only possible for {@link Iso}s and not general {@link LensLike}s because of the mandatory need for the
+ * correspondence <code>B -&gt; T</code>.
+ *
+ * @param <S> the larger type for focusing
+ * @param <T> the larger type for mirrored focusing
+ * @param <A> the smaller type for focusing
+ * @param <B> the smaller type for mirrored focusing
+ */
+public final class Under<S, T, A, B> implements Fn3<Iso<S, T, A, B>, Function<? super T, ? extends S>, B, A> {
+
+    private static final Under INSTANCE = new Under();
+
+    private Under() {
+    }
+
+    @Override
+    public A apply(Iso<S, T, A, B> iso, Function<? super T, ? extends S> fn, B b) {
+        return iso.unIso().into((sa, bt) -> bt.fmap(fn).fmap(sa)).apply(b);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <S, T, A, B> Under<S, T, A, B> under() {
+        return INSTANCE;
+    }
+
+    public static <S, T, A, B> Fn2<Function<? super T, ? extends S>, B, A> under(Iso<S, T, A, B> iso) {
+        return Under.<S, T, A, B>under().apply(iso);
+    }
+
+    public static <S, T, A, B> Fn1<B, A> under(Iso<S, T, A, B> iso, Function<? super T, ? extends S> fn) {
+        return under(iso).apply(fn);
+    }
+
+    public static <S, T, A, B> A under(Iso<S, T, A, B> iso, Function<? super T, ? extends S> fn, B b) {
+        return under(iso, fn).apply(b);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/functions/View.java b/src/main/java/com/jnape/palatable/lambda/lens/functions/View.java
index 86e4990a0..a6d1cb883 100644
--- a/src/main/java/com/jnape/palatable/lambda/lens/functions/View.java
+++ b/src/main/java/com/jnape/palatable/lambda/lens/functions/View.java
@@ -3,7 +3,7 @@
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functor.builtin.Const;
-import com.jnape.palatable.lambda.lens.Lens;
+import com.jnape.palatable.lambda.lens.LensLike;
 
 /**
  * Given a lens and a "larger" value <code>S</code>, retrieve a "smaller" value <code>A</code> by lifting the lens into
@@ -18,7 +18,7 @@
  * @see Set
  * @see Over
  */
-public final class View<S, T, A, B> implements Fn2<Lens<S, T, A, B>, S, A> {
+public final class View<S, T, A, B> implements Fn2<LensLike<S, T, A, B, ?>, S, A> {
 
     private static final View INSTANCE = new View();
 
@@ -26,8 +26,8 @@ private View() {
     }
 
     @Override
-    public A apply(Lens<S, T, A, B> lens, S s) {
-        return lens.<Const<A, ?>, Const<A, T>, Const<A, B>>fix().apply(Const::new, s).runConst();
+    public A apply(LensLike<S, T, A, B, ?> lens, S s) {
+        return lens.<Const<A, ?>, Const<A, T>, Const<A, B>>apply(Const::new, s).runConst();
     }
 
     @SuppressWarnings("unchecked")
@@ -35,11 +35,11 @@ public static <S, T, A, B> View<S, T, A, B> view() {
         return INSTANCE;
     }
 
-    public static <S, T, A, B> Fn1<S, A> view(Lens<S, T, A, B> lens) {
+    public static <S, T, A, B> Fn1<S, A> view(LensLike<S, T, A, B, ?> lens) {
         return View.<S, T, A, B>view().apply(lens);
     }
 
-    public static <S, T, A, B> A view(Lens<S, T, A, B> lens, S s) {
+    public static <S, T, A, B> A view(LensLike<S, T, A, B, ?> lens, S s) {
         return view(lens).apply(s);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/lenses/HListLens.java b/src/main/java/com/jnape/palatable/lambda/lens/lenses/HListLens.java
index 085baeaf2..bc0ce452b 100644
--- a/src/main/java/com/jnape/palatable/lambda/lens/lenses/HListLens.java
+++ b/src/main/java/com/jnape/palatable/lambda/lens/lenses/HListLens.java
@@ -43,7 +43,7 @@ public final class HListLens {
      * @param <Tail> the tail HList type
      * @return a lens that focuses on the tail of an HList
      */
-    public static <Head, Tail extends HList> Lens.Simple<HCons<Head, Tail>, Tail> tail() {
+    public static <Head, Tail extends HList> Lens.Simple<HCons<Head, ? extends Tail>, Tail> tail() {
         return simpleLens(HCons::tail, (hCons, newTail) -> cons(hCons.head(), newTail));
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/lenses/HMapLens.java b/src/main/java/com/jnape/palatable/lambda/lens/lenses/HMapLens.java
new file mode 100644
index 000000000..c7fd953da
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/lens/lenses/HMapLens.java
@@ -0,0 +1,27 @@
+package com.jnape.palatable.lambda.lens.lenses;
+
+import com.jnape.palatable.lambda.adt.Maybe;
+import com.jnape.palatable.lambda.adt.hmap.HMap;
+import com.jnape.palatable.lambda.adt.hmap.TypeSafeKey;
+import com.jnape.palatable.lambda.lens.Lens;
+
+import static com.jnape.palatable.lambda.lens.Lens.simpleLens;
+
+/**
+ * Lenses that operate on {@link HMap}s.
+ */
+public final class HMapLens {
+    private HMapLens() {
+    }
+
+    /**
+     * A lens that focuses on a value at a {@link TypeSafeKey.Simple}&lt;A&gt; in an {@link HMap}, as a {@link Maybe}.
+     *
+     * @param key the key
+     * @param <A> the value type at the key
+     * @return the lens
+     */
+    public static <A> Lens.Simple<HMap, Maybe<A>> valueAt(TypeSafeKey<?, A> key) {
+        return simpleLens(m -> m.get(key), (m, maybeA) -> maybeA.fmap(a -> m.put(key, a)).orElseGet(() -> m.remove(key)));
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/lenses/MapLens.java b/src/main/java/com/jnape/palatable/lambda/lens/lenses/MapLens.java
index f45d535a4..cb393ac1f 100644
--- a/src/main/java/com/jnape/palatable/lambda/lens/lenses/MapLens.java
+++ b/src/main/java/com/jnape/palatable/lambda/lens/lenses/MapLens.java
@@ -3,6 +3,7 @@
 import com.jnape.palatable.lambda.adt.Maybe;
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.builtin.fn2.Filter;
+import com.jnape.palatable.lambda.lens.Iso;
 import com.jnape.palatable.lambda.lens.Lens;
 
 import java.util.ArrayList;
@@ -18,6 +19,7 @@
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.ToCollection.toCollection;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.ToMap.toMap;
+import static com.jnape.palatable.lambda.lens.Lens.Simple.adapt;
 import static com.jnape.palatable.lambda.lens.Lens.simpleLens;
 import static com.jnape.palatable.lambda.lens.functions.View.view;
 import static com.jnape.palatable.lambda.lens.lenses.MaybeLens.unLiftA;
@@ -77,7 +79,7 @@ public static <K, V> Lens.Simple<Map<K, V>, Maybe<V>> valueAt(K k) {
      */
     @SuppressWarnings("unchecked")
     public static <K, V> Lens.Simple<Map<K, V>, V> valueAt(K k, V defaultValue) {
-        return unLiftB(unLiftA(valueAt(k), defaultValue))::apply;
+        return adapt(unLiftB(unLiftA(valueAt(k), defaultValue)));
     }
 
     /**
@@ -156,11 +158,12 @@ public static <K, V> Lens.Simple<Map<K, V>, Map<V, K>> inverted() {
      * @param <V>  the unfocused map value type
      * @param <V2> the focused map value types
      * @return a lens that focuses on a map while mapping its values
+     * @deprecated in favor of the lawful (and far more rational) {@link MapLens#mappingValues(Iso)}
      */
+    @Deprecated
     public static <K, V, V2> Lens.Simple<Map<K, V>, Map<K, V2>> mappingValues(Function<? super V, ? extends V2> fn) {
         return simpleLens(m -> toMap(HashMap::new, map(t -> t.biMapR(fn), map(Tuple2::fromEntry, m.entrySet()))),
                           (s, b) -> {
-                              //todo: remove this madness upon arrival of either invertible functions or Iso<V,V2>
                               Set<K> retainKeys = Filter.<Map.Entry<K, V>>filter(kv -> eq(fn.apply(kv.getValue()), b.get(kv.getKey())))
                                       .andThen(map(Map.Entry::getKey))
                                       .andThen(toCollection(HashSet::new))
@@ -170,4 +173,18 @@ public static <K, V, V2> Lens.Simple<Map<K, V>, Map<K, V2>> mappingValues(Functi
                               return copy;
                           });
     }
+
+    /**
+     * A lens that focuses on a map while mapping its values with the mapping {@link Iso}.
+     *
+     * @param iso  the mapping {@link Iso}
+     * @param <K>  the key type
+     * @param <V>  the unfocused map value type
+     * @param <V2> the focused map value types
+     * @return a lens that focuses on a map while mapping its values
+     */
+    public static <K, V, V2> Lens.Simple<Map<K, V>, Map<K, V2>> mappingValues(Iso<V, V, V2, V2> iso) {
+        return simpleLens(m -> toMap(HashMap::new, map(t -> t.biMapR(view(iso)), map(Tuple2::fromEntry, m.entrySet()))),
+                          (s, b) -> view(mappingValues(iso.mirror()), b));
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/monad/Monad.java b/src/main/java/com/jnape/palatable/lambda/monad/Monad.java
index 770566cbf..11b18d84c 100644
--- a/src/main/java/com/jnape/palatable/lambda/monad/Monad.java
+++ b/src/main/java/com/jnape/palatable/lambda/monad/Monad.java
@@ -4,8 +4,6 @@
 
 import java.util.function.Function;
 
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
-
 /**
  * Monads are {@link Applicative} functors that support a flattening operation to unwrap <code>M&lt;M&lt;A&gt;&gt;
  * -&gt; M&lt;A&gt;</code>. This flattening operation, coupled with {@link Applicative#zip(Applicative)}, gives rise to
@@ -55,7 +53,7 @@ default <B> Monad<B, M> fmap(Function<? super A, ? extends B> fn) {
      */
     @Override
     default <B> Monad<B, M> zip(Applicative<Function<? super A, ? extends B>, M> appFn) {
-        return fmap(a -> appFn.<Monad<Function<? super A, ? extends B>, M>>coerce().<B>fmap(f -> f.apply(a))).flatMap(id());
+        return appFn.<Monad<Function<? super A, ? extends B>, M>>coerce().flatMap(ab -> fmap(ab::apply));
     }
 
     /**
@@ -63,7 +61,7 @@ default <B> Monad<B, M> zip(Applicative<Function<? super A, ? extends B>, M> app
      */
     @Override
     default <B> Monad<B, M> discardL(Applicative<B, M> appB) {
-        return (Monad<B, M>) Applicative.super.discardL(appB);
+        return Applicative.super.discardL(appB).coerce();
     }
 
     /**
@@ -71,6 +69,6 @@ default <B> Monad<B, M> discardL(Applicative<B, M> appB) {
      */
     @Override
     default <B> Monad<A, M> discardR(Applicative<B, M> appB) {
-        return (Monad<A, M>) Applicative.super.discardR(appB);
+        return Applicative.super.discardR(appB).coerce();
     }
 }
\ No newline at end of file
diff --git a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Concat.java b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Concat.java
index f48e4cc5a..ec38b568b 100644
--- a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Concat.java
+++ b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Concat.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.monoid.builtin;
 
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.iterators.ConcatenatingIterator;
+import com.jnape.palatable.lambda.iteration.ConcatenatingIterable;
 import com.jnape.palatable.lambda.monoid.Monoid;
 
 import java.util.Collections;
@@ -25,7 +25,7 @@ public Iterable<A> identity() {
 
     @Override
     public Iterable<A> apply(Iterable<A> xs, Iterable<A> ys) {
-        return () -> new ConcatenatingIterator<>(xs, ys);
+        return new ConcatenatingIterable<>(xs, ys);
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Present.java b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Present.java
index d01911cf0..aa1433c77 100644
--- a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Present.java
+++ b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Present.java
@@ -27,6 +27,8 @@
  */
 public final class Present<A> implements MonoidFactory<Semigroup<A>, Maybe<A>> {
 
+    private static final Present INSTANCE = new Present<>();
+
     private Present() {
     }
 
@@ -36,8 +38,9 @@ public Monoid<Maybe<A>> apply(Semigroup<A> aSemigroup) {
                       nothing());
     }
 
+    @SuppressWarnings("unchecked")
     public static <A> Present<A> present() {
-        return new Present<>();
+        return INSTANCE;
     }
 
     public static <A> Monoid<Maybe<A>> present(Semigroup<A> semigroup) {
diff --git a/src/main/java/com/jnape/palatable/lambda/traversable/LambdaIterable.java b/src/main/java/com/jnape/palatable/lambda/traversable/LambdaIterable.java
index d0f492942..682fd81bf 100644
--- a/src/main/java/com/jnape/palatable/lambda/traversable/LambdaIterable.java
+++ b/src/main/java/com/jnape/palatable/lambda/traversable/LambdaIterable.java
@@ -83,11 +83,12 @@ public <B> LambdaIterable<B> flatMap(Function<? super A, ? extends Monad<B, Lamb
     }
 
     @Override
-    public <B, App extends Applicative> Applicative<LambdaIterable<B>, App> traverse(
-            Function<? super A, ? extends Applicative<B, App>> fn,
-            Function<? super Traversable<B, LambdaIterable>, ? extends Applicative<? extends Traversable<B, LambdaIterable>, App>> pure) {
-        return foldRight((a, appTrav) -> appTrav.zip(fn.apply(a).fmap(b -> bs -> LambdaIterable.<B>wrap(cons(b, bs.unwrap())))),
-                         pure.apply(LambdaIterable.empty()).fmap(ti -> (LambdaIterable<B>) ti),
+    @SuppressWarnings("unchecked")
+    public <B, App extends Applicative, TravB extends Traversable<B, LambdaIterable>, AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super A, ? extends AppB> fn,
+            Function<? super TravB, ? extends AppTrav> pure) {
+        return foldRight((a, appTrav) -> (AppTrav) appTrav.<TravB>zip(fn.apply(a).fmap(b -> bs -> (TravB) wrap(cons(b, ((LambdaIterable<B>) bs).unwrap())))),
+                         (AppTrav) pure.apply((TravB) LambdaIterable.<B>empty()),
                          as);
     }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java b/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java
index fd74b4502..aff6884da 100644
--- a/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java
+++ b/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java
@@ -36,22 +36,21 @@ public interface Traversable<A, T extends Traversable> extends Functor<A, T> {
      * Apply <code>fn</code> to each element of this traversable from left to right, and collapse the results into
      * a single resulting applicative, potentially with the assistance of the applicative's pure function.
      *
-     * @param fn    the function to apply
-     * @param pure  the applicative pure function
-     * @param <B>   the resulting element type
-     * @param <App> the result applicative type
+     * @param fn        the function to apply
+     * @param pure      the applicative pure function
+     * @param <B>       the resulting element type
+     * @param <App>     the result applicative type
+     * @param <TravB>   this Traversable instance over B
+     * @param <AppB>    the result applicative instance over B
+     * @param <AppTrav> the full inferred resulting type from the traversal
      * @return the traversed Traversable, wrapped inside an applicative
      */
-    <B, App extends Applicative> Applicative<? extends Traversable<B, T>, App> traverse(
-            Function<? super A, ? extends Applicative<B, App>> fn,
-            Function<? super Traversable<B, T>, ? extends Applicative<? extends Traversable<B, T>, App>> pure);
+    <B, App extends Applicative, TravB extends Traversable<B, T>, AppB extends Applicative<B, App>,
+            AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super A, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure);
 
     @Override
-    @SuppressWarnings({"Convert2MethodRef", "unchecked"})
     default <B> Traversable<B, T> fmap(Function<? super A, ? extends B> fn) {
-        return traverse(a -> new Identity<>(fn.apply(a)), x -> new Identity<>(x))
-                .fmap(x -> (Traversable<B, T>) x)
-                .<Identity<Traversable<B, T>>>coerce()
-                .runIdentity();
+        return traverse(a -> new Identity<B>(fn.apply(a)), Identity::new).runIdentity();
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
index 407197a8d..a06282ba6 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
@@ -22,6 +22,7 @@
 import static com.jnape.palatable.lambda.adt.Either.right;
 import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
 import static com.jnape.palatable.traitor.framework.Subjects.subjects;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
@@ -186,6 +187,21 @@ public void dyadicTryingLiftsCheckedSupplierMappingAnyThrownExceptions() {
         }, Throwable::getMessage));
     }
 
+    @Test
+    public void dyadicTryingWithRunnable() {
+        assertEquals(right(UNIT), Either.trying(() -> {}, Throwable::getMessage));
+        assertEquals(left("expected"), Either.trying(() -> {
+            throw new IllegalStateException("expected");
+        }, Throwable::getMessage));
+    }
+
+    @Test
+    public void monadTryingWithRunnable() {
+        assertEquals(right(UNIT), Either.trying(() -> {}));
+        IllegalStateException expected = new IllegalStateException("expected");
+        assertEquals(left(expected), Either.trying(() -> {throw expected;}));
+    }
+
     @Test
     public void monadicPeekLiftsIOToTheRight() {
         Either<String, Integer> left = left("foo");
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/TheseTest.java b/src/test/java/com/jnape/palatable/lambda/adt/TheseTest.java
new file mode 100644
index 000000000..ba44c9caf
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/adt/TheseTest.java
@@ -0,0 +1,25 @@
+package com.jnape.palatable.lambda.adt;
+
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.framework.Subjects;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.ApplicativeLaws;
+import testsupport.traits.BifunctorLaws;
+import testsupport.traits.FunctorLaws;
+import testsupport.traits.MonadLaws;
+import testsupport.traits.TraversableLaws;
+
+import static com.jnape.palatable.lambda.adt.These.a;
+import static com.jnape.palatable.lambda.adt.These.b;
+import static com.jnape.palatable.lambda.adt.These.both;
+import static com.jnape.palatable.traitor.framework.Subjects.subjects;
+
+@RunWith(Traits.class)
+public class TheseTest {
+
+    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class, TraversableLaws.class, BifunctorLaws.class})
+    public Subjects<These<String, Integer>> testSubject() {
+        return subjects(a("foo"), b(1), both("foo", 1));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/TryTest.java b/src/test/java/com/jnape/palatable/lambda/adt/TryTest.java
new file mode 100644
index 000000000..362671cf6
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/adt/TryTest.java
@@ -0,0 +1,153 @@
+package com.jnape.palatable.lambda.adt;
+
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.framework.Subjects;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import testsupport.traits.ApplicativeLaws;
+import testsupport.traits.FunctorLaws;
+import testsupport.traits.MonadLaws;
+import testsupport.traits.TraversableLaws;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static com.jnape.palatable.lambda.adt.Either.left;
+import static com.jnape.palatable.lambda.adt.Either.right;
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.Try.failure;
+import static com.jnape.palatable.lambda.adt.Try.success;
+import static com.jnape.palatable.lambda.adt.Try.trying;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.traitor.framework.Subjects.subjects;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.LeftMatcher.isLeftThat;
+
+@RunWith(Traits.class)
+public class TryTest {
+
+    @Rule public ExpectedException thrown = ExpectedException.none();
+
+    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class, TraversableLaws.class})
+    public Subjects<Try<Throwable, Integer>> testSubject() {
+        return subjects(failure(new IllegalStateException()), success(1));
+    }
+
+    @Test
+    public void catchingWithGenericPredicate() {
+        Try<RuntimeException, String> caught = Try.<RuntimeException, String>failure(new RuntimeException())
+                .catching(__ -> false, r -> "caught first")
+                .catching(__ -> true, r -> "caught second");
+
+        assertEquals(success("caught second"), caught);
+    }
+
+    @Test
+    public void catchingIsANoOpForSuccess() {
+        Try<RuntimeException, String> caught = Try.<RuntimeException, String>success("success")
+                .catching(__ -> true, __ -> "caught");
+
+        assertEquals(success("success"), caught);
+    }
+
+    @Test
+    public void firstMatchingCatchBlockWins() {
+        Try<RuntimeException, String> caught = Try.<RuntimeException, String>failure(new IllegalStateException())
+                .catching(__ -> true, __ -> "first")
+                .catching(__ -> true, __ -> "second");
+
+        assertEquals(success("first"), caught);
+    }
+
+    @Test
+    public void catchBasedOnExceptionType() {
+        Try<RuntimeException, String> caught = Try.<RuntimeException, String>failure(new IllegalStateException())
+                .catching(IllegalArgumentException.class, __ -> "illegal argument exception")
+                .catching(IllegalStateException.class, __ -> "illegal state exception")
+                .catching(RuntimeException.class, __ -> "runtime exception");
+
+        assertEquals(success("illegal state exception"), caught);
+    }
+
+    @Test
+    public void ensureIfSuccess() {
+        AtomicInteger invocations = new AtomicInteger(0);
+        Try.success(1).ensuring((invocations::incrementAndGet));
+        assertEquals(1, invocations.get());
+    }
+
+    @Test
+    public void ensureIfFailure() {
+        AtomicInteger invocations = new AtomicInteger(0);
+        Try.failure(new IllegalStateException()).ensuring((invocations::incrementAndGet));
+        assertEquals(1, invocations.get());
+    }
+
+    @Test
+    public void exceptionThrownInEnsuringBlockIsCaught() {
+        IllegalStateException expected = new IllegalStateException();
+        assertEquals(Try.failure(expected), Try.success(1).ensuring(() -> {throw expected;}));
+
+        Either<IllegalArgumentException, Object> actual = Try.failure(new IllegalArgumentException())
+                .ensuring(() -> { throw expected;})
+                .toEither();
+        assertThat(actual, isLeftThat(instanceOf(IllegalArgumentException.class)));
+        assertEquals(left(expected), actual.biMapL(t -> t.getSuppressed()[0]));
+    }
+
+    @Test
+    public void forfeitEnsuresFailure() {
+        IllegalStateException expected = new IllegalStateException();
+        assertEquals(expected, Try.<RuntimeException, Object>failure(expected).forfeit(__ -> new IllegalArgumentException()));
+        assertEquals(expected, Try.<RuntimeException, Object>success(1).forfeit(__ -> expected));
+    }
+
+    @Test
+    public void recoverEnsuresSuccess() {
+        assertEquals((Integer) 1, Try.<RuntimeException, Integer>success(1).recover(constantly(1)));
+        assertEquals((Integer) 1, Try.<RuntimeException, Integer>failure(new IllegalArgumentException()).recover(constantly(1)));
+    }
+
+    @Test
+    public void orThrow() throws Throwable {
+        assertEquals((Integer) 1, trying(() -> 1).orThrow());
+
+        Throwable expected = new Exception("expected");
+        thrown.expect(equalTo(expected));
+        trying(() -> {throw expected;}).orThrow();
+    }
+
+    @Test
+    public void toMaybe() {
+        assertEquals(just("foo"), Try.success("foo").toMaybe());
+        assertEquals(nothing(), Try.failure(new IllegalStateException()).toMaybe());
+    }
+
+    @Test
+    public void toEither() {
+        assertEquals(right("foo"), Try.success("foo").toEither());
+
+        IllegalStateException exception = new IllegalStateException();
+        assertEquals(left(exception), Try.failure(exception).toEither());
+    }
+
+    @Test
+    public void toEitherWithLeftMappingFunction() {
+        assertEquals(right(1), Try.success(1).toEither(__ -> "fail"));
+        assertEquals(left("fail"), Try.failure(new IllegalStateException("fail")).toEither(Throwable::getMessage));
+    }
+
+    @Test
+    public void tryingCatchesAnyThrowableThrownDuringEvaluation() {
+        IllegalStateException expected = new IllegalStateException();
+        assertEquals(failure(expected), trying(() -> {throw expected;}));
+
+        assertEquals(success("foo"), trying(() -> "foo"));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java
index 9638d745e..36f9a44cc 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java
@@ -105,7 +105,7 @@ public void staticFactoryMethodFromMapEntry() {
     public void zipPrecedence() {
         Tuple2<String, Integer> a = tuple("foo", 1);
         Tuple2<String, Function<? super Integer, ? extends Integer>> b = tuple("bar", x -> x + 1);
-        assertEquals(tuple("foo", 2), a.zip(b));
+        assertEquals(tuple("bar", 2), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java
index 64179b33a..248dd03e1 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java
@@ -92,7 +92,7 @@ public void fill() {
     public void zipPrecedence() {
         Tuple5<String, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4);
         Tuple5<String, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 5), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple6Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple6Test.java
index ee2020c4d..bd31aca1a 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple6Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple6Test.java
@@ -96,7 +96,7 @@ public void fill() {
     public void zipPrecedence() {
         Tuple6<String, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5);
         Tuple6<String, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 4, 6), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5, 6), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple7Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple7Test.java
index 4025e470b..a62a36691 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple7Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple7Test.java
@@ -99,7 +99,7 @@ public void into() {
     public void zipPrecedence() {
         Tuple7<String, Integer, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5, 6);
         Tuple7<String, Integer, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, 6, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 4, 5, 7), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5, 6, 7), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple8Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple8Test.java
index a127cbc08..c19ee8a58 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple8Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple8Test.java
@@ -102,7 +102,7 @@ public void into() {
     public void zipPrecedence() {
         Tuple8<String, Integer, Integer, Integer, Integer, Integer, Integer, Integer> a = tuple("foo", 1, 2, 3, 4, 5, 6, 7);
         Tuple8<String, Integer, Integer, Integer, Integer, Integer, Integer, Function<? super Integer, ? extends Integer>> b = tuple("bar", 2, 3, 4, 5, 6, 7, x -> x + 1);
-        assertEquals(tuple("foo", 1, 2, 3, 4, 5, 6, 8), a.zip(b));
+        assertEquals(tuple("bar", 2, 3, 4, 5, 6, 7, 8), a.zip(b));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hmap/HMapTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hmap/HMapTest.java
index 7bc55ff77..8495b059f 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hmap/HMapTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hmap/HMapTest.java
@@ -24,7 +24,7 @@ public class HMapTest {
 
     @Test
     public void getForPresentKey() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
         assertEquals(just("string value"),
                      singletonHMap(stringKey, "string value").get(stringKey));
     }
@@ -38,14 +38,14 @@ public void getForAbsentKey() {
 
     @Test
     public void getForPresentKeyWithNullValue() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
         assertEquals(nothing(),
                      singletonHMap(stringKey, null).get(stringKey));
     }
 
     @Test
     public void put() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
         assertEquals(singletonHMap(stringKey, "string value"),
                      emptyHMap().put(stringKey, "string value"));
 
@@ -57,9 +57,9 @@ public void put() {
 
     @Test
     public void putAll() {
-        TypeSafeKey<String> stringKey1 = typeSafeKey();
-        TypeSafeKey<String> stringKey2 = typeSafeKey();
-        TypeSafeKey<Integer> intKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey1 = typeSafeKey();
+        TypeSafeKey<String, String> stringKey2 = typeSafeKey();
+        TypeSafeKey<Integer, Integer> intKey = typeSafeKey();
 
         HMap left = hMap(stringKey1, "string value",
                          intKey, 1);
@@ -78,8 +78,8 @@ public void putAll() {
 
     @Test
     public void remove() {
-        TypeSafeKey<String> stringKey1 = typeSafeKey();
-        TypeSafeKey<String> stringKey2 = typeSafeKey();
+        TypeSafeKey<String, String> stringKey1 = typeSafeKey();
+        TypeSafeKey<String, String> stringKey2 = typeSafeKey();
         assertEquals(emptyHMap(),
                      emptyHMap()
                              .put(stringKey1, "string value")
@@ -94,8 +94,8 @@ public void remove() {
 
     @Test
     public void removeAll() {
-        TypeSafeKey<String> stringKey1 = typeSafeKey();
-        TypeSafeKey<String> stringKey2 = typeSafeKey();
+        TypeSafeKey<String, String> stringKey1 = typeSafeKey();
+        TypeSafeKey<String, String> stringKey2 = typeSafeKey();
 
         HMap hMap1 = hMap(stringKey1, "foo",
                           stringKey2, "bar");
@@ -107,9 +107,9 @@ public void removeAll() {
 
     @Test
     public void containsKey() {
-        TypeSafeKey<String> stringKey1 = typeSafeKey();
-        TypeSafeKey<String> stringKey2 = typeSafeKey();
-        TypeSafeKey<Integer> intKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey1 = typeSafeKey();
+        TypeSafeKey<String, String> stringKey2 = typeSafeKey();
+        TypeSafeKey<Integer, Integer> intKey = typeSafeKey();
 
         HMap hMap = singletonHMap(stringKey1, "string");
 
@@ -120,7 +120,7 @@ public void containsKey() {
 
     @Test
     public void demandForPresentKey() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
         assertEquals("string value",
                      singletonHMap(stringKey, "string value").demand(stringKey));
     }
@@ -132,8 +132,8 @@ public void demandForAbsentKey() {
 
     @Test
     public void toMap() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
-        TypeSafeKey<Integer> intKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
+        TypeSafeKey<Integer, Integer> intKey = typeSafeKey();
 
         assertEquals(new HashMap<TypeSafeKey, Object>() {{
             put(stringKey, "string");
@@ -144,7 +144,7 @@ public void toMap() {
 
     @Test
     public void iteratesKVPairsAsTuples() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
 
         assertThat(singletonHMap(stringKey, "string value"),
                    iterates(tuple(stringKey, "string value")));
@@ -152,7 +152,7 @@ public void iteratesKVPairsAsTuples() {
 
     @Test
     public void keys() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
 
         assertThat(singletonHMap(stringKey, "string value").keys(),
                    iterates(stringKey));
@@ -166,9 +166,9 @@ public void values() {
 
     @Test
     public void convenienceStaticFactoryMethods() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
-        TypeSafeKey<Integer> intKey = typeSafeKey();
-        TypeSafeKey<Float> floatKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
+        TypeSafeKey<Integer, Integer> intKey = typeSafeKey();
+        TypeSafeKey<Float, Float> floatKey = typeSafeKey();
         assertEquals(emptyHMap().put(stringKey, "string value"),
                      singletonHMap(stringKey, "string value"));
         assertEquals(emptyHMap().put(stringKey, "string value").put(intKey, 1),
@@ -183,22 +183,22 @@ public void convenienceStaticFactoryMethods() {
     @Test
     @SuppressWarnings("EqualsWithItself")
     public void equality() {
-        assertTrue(emptyHMap().equals(emptyHMap()));
+        assertEquals(emptyHMap(), emptyHMap());
 
-        TypeSafeKey<String> stringKey = typeSafeKey();
-        assertTrue(emptyHMap().put(stringKey, "one").equals(emptyHMap().put(stringKey, "one")));
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
+        assertEquals(emptyHMap().put(stringKey, "one"), emptyHMap().put(stringKey, "one"));
 
-        assertFalse(emptyHMap().equals(emptyHMap().put(stringKey, "string key")));
-        assertFalse(emptyHMap().put(stringKey, "string key").equals(emptyHMap()));
-        assertFalse(emptyHMap().put(typeSafeKey(), "one").equals(emptyHMap().put(typeSafeKey(), "one")));
-        assertFalse(emptyHMap().put(typeSafeKey(), "one").equals(emptyHMap().put(typeSafeKey(), 1)));
-        assertFalse(emptyHMap().put(typeSafeKey(), 1).equals(emptyHMap().put(typeSafeKey(), "one")));
+        assertNotEquals(emptyHMap(), emptyHMap().put(stringKey, "string key"));
+        assertNotEquals(emptyHMap().put(stringKey, "string key"), emptyHMap());
+        assertNotEquals(emptyHMap().put(typeSafeKey(), "one"), emptyHMap().put(typeSafeKey(), "one"));
+        assertNotEquals(emptyHMap().put(typeSafeKey(), "one"), emptyHMap().put(typeSafeKey(), 1));
+        assertNotEquals(emptyHMap().put(typeSafeKey(), 1), emptyHMap().put(typeSafeKey(), "one"));
     }
 
     @Test
     public void hashCodeUsesDecentDistribution() {
         assertEquals(emptyHMap().hashCode(), emptyHMap().hashCode());
-        TypeSafeKey<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
         assertEquals(singletonHMap(stringKey, "string value").hashCode(),
                      singletonHMap(stringKey, "string value").hashCode());
 
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hmap/SimpleTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hmap/SimpleTest.java
new file mode 100644
index 000000000..d3a908a99
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hmap/SimpleTest.java
@@ -0,0 +1,14 @@
+package com.jnape.palatable.lambda.adt.hmap;
+
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.adt.hmap.TypeSafeKey.typeSafeKey;
+import static org.junit.Assert.assertNotEquals;
+
+public class SimpleTest {
+
+    @Test
+    public void usesReferenceEquality() {
+        assertNotEquals(typeSafeKey(), typeSafeKey());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKeyTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKeyTest.java
index dbd29379e..577902c8c 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKeyTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKeyTest.java
@@ -2,13 +2,47 @@
 
 import org.junit.Test;
 
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.adt.hmap.HMap.emptyHMap;
 import static com.jnape.palatable.lambda.adt.hmap.TypeSafeKey.typeSafeKey;
-import static org.junit.Assert.assertFalse;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.lens.Iso.simpleIso;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static testsupport.assertion.LensAssert.assertLensLawfulness;
+
 
 public class TypeSafeKeyTest {
 
     @Test
-    public void usesReferenceEquality() {
-        assertFalse(typeSafeKey().equals(typeSafeKey()));
+    public void lensLawfulness() {
+        assertLensLawfulness(TypeSafeKey.<String>typeSafeKey().andThen(simpleIso(Integer::parseInt, Object::toString)),
+                             asList("123", "0"),
+                             asList(456, -1));
+    }
+
+    @Test
+    public void compositionMapsOriginalValueInAndOutOfHMap() {
+        TypeSafeKey.Simple<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, Integer> intKey = stringKey.andThen(simpleIso(Integer::parseInt, Object::toString));
+        HMap map = emptyHMap().put(stringKey, "123");
+
+        assertEquals(just("123"), map.get(stringKey));
+        assertEquals(just(123), map.get(intKey));
+
+        HMap updated = map.put(intKey, 456);
+        assertEquals(just("456"), updated.get(stringKey));
+        assertEquals(just(456), updated.get(intKey));
+
+        assertEquals(1, updated.keys().size());
+    }
+
+    @Test
+    public void discardRPreservesTypeSafeKey() {
+        TypeSafeKey.Simple<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, String> discardedKey = stringKey.discardR(simpleIso(id(), id()));
+        HMap map = emptyHMap().put(stringKey, "123");
+
+        assertEquals(just("123"), map.get(discardedKey));
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/MagnetizeTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/MagnetizeTest.java
new file mode 100644
index 000000000..87f5a983e
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/MagnetizeTest.java
@@ -0,0 +1,38 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import testsupport.traits.EmptyIterableSupport;
+import testsupport.traits.FiniteIteration;
+import testsupport.traits.ImmutableIteration;
+import testsupport.traits.InfiniteIterableSupport;
+import testsupport.traits.Laziness;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Magnetize.magnetize;
+import static java.util.Arrays.asList;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class MagnetizeTest {
+
+    @TestTraits({EmptyIterableSupport.class, InfiniteIterableSupport.class, FiniteIteration.class, ImmutableIteration.class, Laziness.class})
+    public Fn1<Iterable<Object>, Iterable<Iterable<Object>>> testSubject() {
+        return magnetize();
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void magnetizesElementsByPredicateOutcome() {
+        assertThat(magnetize(asList(1, 1, 2, 3, 3, 3, 2, 2, 1)),
+                   contains(iterates(1, 1),
+                            iterates(2),
+                            iterates(3, 3, 3),
+                            iterates(2, 2),
+                            iterates(1)));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/TailsTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/TailsTest.java
index 15960accf..45b3a1b25 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/TailsTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/TailsTest.java
@@ -49,6 +49,6 @@ public void nonEmpty() {
 
     @Test
     public void largeNumberOfElements() {
-        assertEquals(just(emptyList()), last(tails(take(100000, repeat(1)))));
+        assertEquals(just(emptyList()), last(tails(take(10_000, repeat(1)))));
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/BothTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/BothTest.java
new file mode 100644
index 000000000..961d2679c
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/BothTest.java
@@ -0,0 +1,15 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Both.both;
+import static org.junit.Assert.assertEquals;
+
+public class BothTest {
+
+    @Test
+    public void duallyAppliesTwoFunctionsToSameInput() {
+        assertEquals(tuple(1, -1), both(x -> x + 1, x -> x - 1, 0));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java
index 329fd13e2..62dc0e73b 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java
@@ -10,8 +10,13 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Head.head;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Drop.drop;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.Times.times;
 import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -27,4 +32,10 @@ public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
     public void dropsElementsUpToLimit() {
         assertThat(drop(2, asList(1, 2, 3, 4)), iterates(3, 4));
     }
+
+    @Test
+    public void stackSafety() {
+        int stackBlowingNumber = 10_000;
+        assertEquals(just(1), head(times(stackBlowingNumber, drop(1), repeat(1))));
+    }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java
index 352aa47b4..b57ae8085 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java
@@ -23,7 +23,7 @@ public class DropWhileTest {
 
     @TestTraits({Laziness.class, ImmutableIteration.class, FiniteIteration.class, EmptyIterableSupport.class})
     public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
-        return dropWhile(constantly(true));
+        return dropWhile(constantly(false));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MagnetizeByTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MagnetizeByTest.java
new file mode 100644
index 000000000..1995332f2
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MagnetizeByTest.java
@@ -0,0 +1,56 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import testsupport.traits.EmptyIterableSupport;
+import testsupport.traits.FiniteIteration;
+import testsupport.traits.ImmutableIteration;
+import testsupport.traits.InfiniteIterableSupport;
+import testsupport.traits.Laziness;
+
+import java.util.function.BiFunction;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Last.last;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Eq.eq;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.MagnetizeBy.magnetizeBy;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.isEmpty;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class MagnetizeByTest {
+
+    @TestTraits({EmptyIterableSupport.class, InfiniteIterableSupport.class, FiniteIteration.class, ImmutableIteration.class, Laziness.class})
+    public Fn1<Iterable<Object>, Iterable<Iterable<Object>>> testSubject() {
+        return magnetizeBy(eq().toBiFunction());
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void magnetizesElementsByPredicateOutcome() {
+        BiFunction<Integer, Integer, Boolean> lte = (x, y) -> x <= y;
+        assertThat(magnetizeBy(lte, emptyList()), isEmpty());
+        assertThat(magnetizeBy(lte, singletonList(1)), contains(iterates(1)));
+        assertThat(magnetizeBy(lte, asList(1, 2, 3, 2, 2, 3, 2, 1)),
+                   contains(iterates(1, 2, 3),
+                            iterates(2, 2, 3),
+                            iterates(2),
+                            iterates(1)));
+    }
+
+    @Test
+    public void stackSafety() {
+        int stackBlowingNumber = 10_000;
+        assertThat(last(magnetizeBy((x, y) -> false, take(stackBlowingNumber, repeat(1)))).orElseThrow(AssertionError::new),
+                   iterates(1));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SequenceTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SequenceTest.java
index 3eea6917f..73b45f407 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SequenceTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SequenceTest.java
@@ -1,6 +1,7 @@
 package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import com.jnape.palatable.lambda.adt.Either;
+import com.jnape.palatable.lambda.adt.Maybe;
 import com.jnape.palatable.lambda.functor.builtin.Compose;
 import com.jnape.palatable.lambda.functor.builtin.Identity;
 import org.junit.Test;
@@ -8,6 +9,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.adt.Either.right;
+import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Sequence.sequence;
 import static java.util.Arrays.asList;
@@ -29,15 +31,15 @@ public void naturality() {
     @Test
     public void identity() {
         Either<String, Identity<Integer>> traversable = right(new Identity<>(1));
-        assertEquals(sequence(traversable.fmap(Identity::new), Identity::new),
-                     new Identity<>(traversable));
+        assertEquals(new Identity<>(traversable),
+                     sequence(traversable.fmap(Identity::new), Identity::new));
     }
 
     @Test
     public void composition() {
         Either<String, Identity<Either<String, Integer>>> traversable = right(new Identity<>(right(1)));
-        assertEquals(sequence(traversable.fmap(x -> new Compose<>(x.fmap(id()))), x -> new Compose<>(new Identity<>(right(x)))),
-                     new Compose<>(sequence(traversable, Identity::new).fmap(x -> sequence(x, Either::right)).fmap(id())));
+        assertEquals(new Compose<>(sequence(traversable, Identity::new).fmap(x -> sequence(x, Either::right)).fmap(id())),
+                     sequence(traversable.fmap(x -> new Compose<>(x.fmap(id()))), x -> new Compose<>(new Identity<>(right(x)))));
     }
 
     @Test
@@ -46,4 +48,19 @@ public void iterableSpecialization() {
                            .orThrow(l -> new AssertionError("Expected a right value, but was a left value of <" + l + ">")),
                    iterates(1, 2));
     }
+
+    @Test
+    public void compilation() {
+        Either<String, Maybe<Integer>> a = sequence(just(right(1)), Either::right);
+        assertEquals(right(just(1)), a);
+
+        Maybe<Either<String, Integer>> b = sequence(right(just(1)), Maybe::just);
+        assertEquals(just(right(1)), b);
+
+        Either<String, Maybe<Integer>> c = sequence(b, Either::right);
+        assertEquals(a, c);
+
+        Maybe<Iterable<Integer>> d = sequence(asList(just(1), just(2)), Maybe::just);
+        assertThat(d.orElseThrow(AssertionError::new), iterates(1, 2));
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SpanTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SpanTest.java
new file mode 100644
index 000000000..c29320506
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SpanTest.java
@@ -0,0 +1,37 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.monoid.builtin.Concat;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import testsupport.traits.EmptyIterableSupport;
+import testsupport.traits.FiniteIteration;
+import testsupport.traits.ImmutableIteration;
+import testsupport.traits.InfiniteIterableSupport;
+import testsupport.traits.Laziness;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Eq.eq;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Into.into;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Span.span;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class SpanTest {
+
+    @TestTraits({EmptyIterableSupport.class, InfiniteIterableSupport.class, FiniteIteration.class, ImmutableIteration.class, Laziness.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return span(eq(0)).fmap(into(Concat::concat));
+    }
+
+    @Test
+    public void splitsIterableAfterPredicateFailure() {
+        Tuple2<Iterable<Integer>, Iterable<Integer>> spanned = span(eq(1), asList(1, 1, 1, 2, 3, 1));
+        assertThat(spanned._1(), iterates(1, 1, 1));
+        assertThat(spanned._2(), iterates(2, 3, 1));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2Test.java
index 159878c0c..93556ebe9 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2Test.java
@@ -16,7 +16,7 @@ public class LiftA2Test {
     public void liftsAndAppliesDyadicFunctionToTwoApplicatives() {
         BiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;
         assertEquals(right(3), liftA2(add, right(1), right(2)).coerce());
-        assertEquals(tuple(2, 5), liftA2(add, tuple(1, 2), tuple(2, 3)).coerce());
+        assertEquals(tuple(1, 5), liftA2(add, tuple(1, 2), tuple(2, 3)).coerce());
         assertEquals(new Identity<>(3), liftA2(add, new Identity<>(1), new Identity<>(2)));
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn4/IfThenElseTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn4/IfThenElseTest.java
new file mode 100644
index 000000000..70e1af6ab
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn4/IfThenElseTest.java
@@ -0,0 +1,21 @@
+package com.jnape.palatable.lambda.functions.builtin.fn4;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.specialized.Predicate;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn4.IfThenElse.ifThenElse;
+import static org.junit.Assert.assertEquals;
+
+public class IfThenElseTest {
+
+    @Test
+    public void standardLogic() {
+        Predicate<Integer> even = x -> x % 2 == 0;
+        Fn1<Integer, Integer> inc = x -> x + 1;
+        Fn1<Integer, Integer> dec = x -> x - 1;
+
+        assertEquals((Integer) 3, ifThenElse(even, inc, dec, 2));
+        assertEquals((Integer) 0, ifThenElse(even, inc, dec, 1));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/specialized/KleisliTest.java b/src/test/java/com/jnape/palatable/lambda/functions/specialized/KleisliTest.java
new file mode 100644
index 000000000..bd40b2dca
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/specialized/KleisliTest.java
@@ -0,0 +1,26 @@
+package com.jnape.palatable.lambda.functions.specialized;
+
+import com.jnape.palatable.lambda.functor.builtin.Identity;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.functions.specialized.Kleisli.kleisli;
+import static java.lang.Integer.parseInt;
+import static org.junit.Assert.assertEquals;
+
+public class KleisliTest {
+
+    private static final Kleisli<Integer, String, Identity, Identity<String>>  G = kleisli(i -> new Identity<>(i.toString()));
+    private static final Kleisli<String, Integer, Identity, Identity<Integer>> F = kleisli(s -> new Identity<>(parseInt(s)));
+
+    @Test
+    public void leftToRightComposition() {
+        assertEquals(new Identity<>(1), G.andThen(F).apply(1));
+        assertEquals(new Identity<>("1"), F.andThen(G).apply("1"));
+    }
+
+    @Test
+    public void rightToLeftComposition() {
+        assertEquals(new Identity<>("1"), G.compose(F).apply("1"));
+        assertEquals(new Identity<>(1), F.compose(G).apply(1));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/CombinatorialIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/CombinatorialIteratorTest.java
similarity index 97%
rename from src/test/java/com/jnape/palatable/lambda/iterators/CombinatorialIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/CombinatorialIteratorTest.java
index ecfa8faab..7678bd2c4 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/CombinatorialIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/CombinatorialIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/ConcatenatingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ConcatenatingIterableTest.java
new file mode 100644
index 000000000..c9e9faf61
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/ConcatenatingIterableTest.java
@@ -0,0 +1,37 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.monoid.builtin.Concat;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.framework.Subjects;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Last.last;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Replicate.replicate;
+import static com.jnape.palatable.traitor.framework.Subjects.subjects;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertEquals;
+
+@RunWith(Traits.class)
+public class ConcatenatingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Subjects<Fn1<Iterable<Integer>, Iterable<Integer>>> testSubject() {
+        return subjects(xs -> new ConcatenatingIterable<>(emptyList(), xs),
+                        xs -> new ConcatenatingIterable<>(xs, emptyList()),
+                        xs -> new ConcatenatingIterable<>(repeat(1), xs),
+                        xs -> new ConcatenatingIterable<>(xs, repeat(1)));
+    }
+
+    @Test
+    public void stackSafety() {
+        Iterable<Integer> xs = Concat.<Integer>concat().reduceLeft(replicate(1_000_000, asList(1, 2, 3)));
+        assertEquals(just(3), last(xs));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ConsingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ConsingIteratorTest.java
similarity index 95%
rename from src/test/java/com/jnape/palatable/lambda/iterators/ConsingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/ConsingIteratorTest.java
index 467a4b138..68f99d943 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ConsingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/ConsingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -50,7 +50,7 @@ public void doesNotHaveNextIfNoElementsLeft() {
 
     @Test
     public void stackSafety() {
-        Integer stackBlowingNumber = 1000000;
+        Integer stackBlowingNumber = 10_000;
         Iterable<Integer> ints = foldRight((x, acc) -> () -> new ConsingIterator<>(x, acc),
                                            (Iterable<Integer>) Collections.<Integer>emptyList(),
                                            take(stackBlowingNumber, iterate(x -> x + 1, 1)));
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/CyclicIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/CyclicIterableTest.java
new file mode 100644
index 000000000..66938afa1
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/CyclicIterableTest.java
@@ -0,0 +1,16 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+@RunWith(Traits.class)
+public class CyclicIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<?>, Iterable<?>> testSubject() {
+        return CyclicIterable::new;
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/CyclicIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/CyclicIteratorTest.java
similarity index 93%
rename from src/test/java/com/jnape/palatable/lambda/iterators/CyclicIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/CyclicIteratorTest.java
index 80c85a895..ba7e84485 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/CyclicIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/CyclicIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Test;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/DistinctIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/DistinctIterableTest.java
new file mode 100644
index 000000000..69a2bd252
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/DistinctIterableTest.java
@@ -0,0 +1,16 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+@RunWith(Traits.class)
+public class DistinctIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<?>, Iterable<?>> testSubject() {
+        return DistinctIterable::new;
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/DroppingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/DroppingIterableTest.java
new file mode 100644
index 000000000..52ab7899f
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/DroppingIterableTest.java
@@ -0,0 +1,16 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+@RunWith(Traits.class)
+public class DroppingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<?>, Iterable<?>> testSubject() {
+        return x -> new DroppingIterable<>(1, x);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/DroppingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/DroppingIteratorTest.java
similarity index 96%
rename from src/test/java/com/jnape/palatable/lambda/iterators/DroppingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/DroppingIteratorTest.java
index e5a09fb77..0e28a2dd2 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/DroppingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/DroppingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/FilteringIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/FilteringIterableTest.java
new file mode 100644
index 000000000..7d1c645d6
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/FilteringIterableTest.java
@@ -0,0 +1,19 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Filter.filter;
+
+@RunWith(Traits.class)
+public class FilteringIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return filter(constantly(true));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/FilteringIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/FilteringIteratorTest.java
similarity index 96%
rename from src/test/java/com/jnape/palatable/lambda/iterators/FilteringIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/FilteringIteratorTest.java
index 55481a9fc..5f2c3cb7e 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/FilteringIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/FilteringIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Test;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/FlatteningIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/FlatteningIteratorTest.java
similarity index 70%
rename from src/test/java/com/jnape/palatable/lambda/iterators/FlatteningIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/FlatteningIteratorTest.java
index e33cb656b..7288e8fbc 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/FlatteningIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/FlatteningIteratorTest.java
@@ -1,7 +1,9 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Test;
 
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Magnetize.magnetize;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyIterator;
 import static java.util.Collections.emptyList;
@@ -25,10 +27,15 @@ public void doesNotHaveNextForIterableOfEmptyIterables() {
 
     @Test
     public void iteratesNestedIterables() {
-        FlatteningIterator<Object> iterator = new FlatteningIterator<>(asList(singletonList(1), asList(2,3), emptyList()).iterator());
+        FlatteningIterator<Object> iterator = new FlatteningIterator<>(asList(singletonList(1), asList(2, 3), emptyList()).iterator());
         assertEquals(1, iterator.next());
         assertEquals(2, iterator.next());
         assertEquals(3, iterator.next());
         assertFalse(iterator.hasNext());
     }
+
+    @Test(timeout = 500)
+    public void betterLaziness() {
+        assertEquals((Integer) 1, new FlatteningIterator<>(magnetize(repeat(1)).iterator()).next());
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/GroupingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/GroupingIteratorTest.java
similarity index 96%
rename from src/test/java/com/jnape/palatable/lambda/iterators/GroupingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/GroupingIteratorTest.java
index 98084dea3..0caab11a5 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/GroupingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/GroupingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ImmutableIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ImmutableIteratorTest.java
similarity index 93%
rename from src/test/java/com/jnape/palatable/lambda/iterators/ImmutableIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/ImmutableIteratorTest.java
index 226cdd675..d1ffc6ebd 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ImmutableIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/ImmutableIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/InfiniteIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/InfiniteIteratorTest.java
similarity index 94%
rename from src/test/java/com/jnape/palatable/lambda/iterators/InfiniteIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/InfiniteIteratorTest.java
index 428541d91..9d9f8abd5 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/InfiniteIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/InfiniteIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/InitIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/InitIteratorTest.java
similarity index 95%
rename from src/test/java/com/jnape/palatable/lambda/iterators/InitIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/InitIteratorTest.java
index 32eeabce0..04c512cb3 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/InitIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/InitIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Test;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/MappingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/MappingIterableTest.java
new file mode 100644
index 000000000..fdddf37e0
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/MappingIterableTest.java
@@ -0,0 +1,19 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
+
+@RunWith(Traits.class)
+public class MappingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Object>, Iterable<Object>> testSubject() {
+        return map(id());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/MappingIteratorTest.java
similarity index 92%
rename from src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/MappingIteratorTest.java
index da1469db9..c4522f8c1 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/MappingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterableTest.java
new file mode 100644
index 000000000..2202c2b98
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIterableTest.java
@@ -0,0 +1,19 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.DropWhile.dropWhile;
+
+@RunWith(Traits.class)
+public class PredicatedDroppingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return dropWhile(constantly(false));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIteratorTest.java
similarity index 97%
rename from src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIteratorTest.java
index b597da2a0..68f933a9a 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedDroppingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Before;
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterableTest.java
new file mode 100644
index 000000000..bb8738cc5
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIterableTest.java
@@ -0,0 +1,19 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.TakeWhile.takeWhile;
+
+@RunWith(Traits.class)
+public class PredicatedTakingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return takeWhile(constantly(true));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIteratorTest.java
similarity index 98%
rename from src/test/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIteratorTest.java
index 6e817057b..833ad43c8 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/PredicatedTakingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import com.jnape.palatable.lambda.functions.specialized.Predicate;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/PrependingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/PrependingIteratorTest.java
similarity index 96%
rename from src/test/java/com/jnape/palatable/lambda/iterators/PrependingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/PrependingIteratorTest.java
index 8f4eaa173..84bdebc1a 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/PrependingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/PrependingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/RepetitiousIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/RepetitiousIteratorTest.java
similarity index 94%
rename from src/test/java/com/jnape/palatable/lambda/iterators/RepetitiousIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/RepetitiousIteratorTest.java
index 2d284c00a..bcf9d2628 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/RepetitiousIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/RepetitiousIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/ReversingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ReversingIterableTest.java
new file mode 100644
index 000000000..e70b7cbd9
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/ReversingIterableTest.java
@@ -0,0 +1,18 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse;
+
+@RunWith(Traits.class)
+public class ReversingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return reverse();
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ReversingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ReversingIteratorTest.java
similarity index 97%
rename from src/test/java/com/jnape/palatable/lambda/iterators/ReversingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/ReversingIteratorTest.java
index 22164a729..754345bfb 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ReversingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/ReversingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/RewindableIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/RewindableIteratorTest.java
similarity index 97%
rename from src/test/java/com/jnape/palatable/lambda/iterators/RewindableIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/RewindableIteratorTest.java
index 544e23fed..3e1498b90 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/RewindableIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/RewindableIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ScanningIteratorTest.java
similarity index 96%
rename from src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/ScanningIteratorTest.java
index 387bc965e..cde0c2f1b 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/ScanningIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Test;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/SnocIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/SnocIterableTest.java
new file mode 100644
index 000000000..258e872a3
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/SnocIterableTest.java
@@ -0,0 +1,16 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+@RunWith(Traits.class)
+public class SnocIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Object>, Iterable<Object>> testSubject() {
+        return xs -> new SnocIterable<>(1, xs);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/SnocIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/SnocIteratorTest.java
similarity index 50%
rename from src/test/java/com/jnape/palatable/lambda/iterators/SnocIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/SnocIteratorTest.java
index a0b156a57..6fca49817 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/SnocIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/SnocIteratorTest.java
@@ -1,16 +1,10 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
 
-import java.util.Collections;
-
-import static com.jnape.palatable.lambda.adt.Maybe.just;
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Last.last;
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Iterate.iterate;
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
-import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft;
 import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -21,7 +15,7 @@ public class SnocIteratorTest {
 
     @Before
     public void setUp() {
-        iterator = new SnocIterator<>(3, asList(1, 2));
+        iterator = new SnocIterator<>(asList(1, 2).iterator(), singletonList(3).iterator());
     }
 
     @Test
@@ -45,14 +39,4 @@ public void doesNotHaveNextIfLastIterated() {
         iterator.next();
         assertFalse(iterator.hasNext());
     }
-
-    @Test
-    public void stackSafety() {
-        int stackBlowingNumber = 100000;
-        Iterable<Integer> ints = foldLeft((xs, x) -> () -> new SnocIterator<>(x, xs),
-                                          Collections::emptyIterator,
-                                          take(stackBlowingNumber, iterate(x -> x + 1, 1)));
-
-        assertEquals(just(stackBlowingNumber), last(ints));
-    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iteration/TakingIterableTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/TakingIterableTest.java
new file mode 100644
index 000000000..b1bd84454
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/TakingIterableTest.java
@@ -0,0 +1,18 @@
+package com.jnape.palatable.lambda.iteration;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.runner.RunWith;
+import testsupport.traits.Deforesting;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
+
+@RunWith(Traits.class)
+public class TakingIterableTest {
+
+    @TestTraits({Deforesting.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return take(1);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/TakingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/TakingIteratorTest.java
similarity index 97%
rename from src/test/java/com/jnape/palatable/lambda/iterators/TakingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/TakingIteratorTest.java
index 9b335554a..9f17bcf4d 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/TakingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/TakingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Test;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/UnfoldingIteratorTest.java
similarity index 61%
rename from src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/UnfoldingIteratorTest.java
index 2bcb6474a..68fa1ec9c 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/UnfoldingIteratorTest.java
@@ -1,14 +1,17 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import com.jnape.palatable.lambda.adt.Maybe;
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
 public class UnfoldingIteratorTest {
@@ -24,4 +27,17 @@ public void hasNextIfFunctionProducesPresentValue() {
     public void doesNotHaveNextIfFunctionProducesEmptyValue() {
         assertThat(new UnfoldingIterator<String, Integer>(x -> nothing(), 0).hasNext(), is(false));
     }
+
+    @Test
+    public void defersNextCallForAsLongAsPossible() {
+        AtomicInteger invocations = new AtomicInteger(0);
+        UnfoldingIterator<String, Integer> iterator = new UnfoldingIterator<>(x -> {
+            invocations.incrementAndGet();
+            return just(tuple(x.toString(), x + 1));
+        }, 1);
+
+        assertEquals(0, invocations.get());
+        iterator.next();
+        assertEquals(1, invocations.get());
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iteration/ZippingIteratorTest.java
similarity index 97%
rename from src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java
rename to src/test/java/com/jnape/palatable/lambda/iteration/ZippingIteratorTest.java
index 561eb2534..f88705a91 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iteration/ZippingIteratorTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.iterators;
+package com.jnape.palatable.lambda.iteration;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ConcatenatingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/ConcatenatingIteratorTest.java
deleted file mode 100644
index 47c360f0e..000000000
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ConcatenatingIteratorTest.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package com.jnape.palatable.lambda.iterators;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import java.util.Collections;
-import java.util.Iterator;
-
-import static com.jnape.palatable.lambda.adt.Maybe.just;
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Last.last;
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Size.size;
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Iterate.iterate;
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
-import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldRight.foldRight;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-import static testsupport.Mocking.mockIteratorToHaveValues;
-
-@RunWith(MockitoJUnitRunner.class)
-public class ConcatenatingIteratorTest {
-
-    @Mock private Iterator<Integer> xs;
-    @Mock private Iterator<Integer> ys;
-
-    private ConcatenatingIterator<Integer> concatenatingIterator;
-
-    @Before
-    public void setUp() throws Exception {
-        concatenatingIterator = new ConcatenatingIterator<>(() -> xs, () -> ys);
-    }
-
-    @Test
-    public void hasNextIfMoreXsAndMoreYs() {
-        when(xs.hasNext()).thenReturn(true);
-        when(ys.hasNext()).thenReturn(true);
-
-        assertTrue(concatenatingIterator.hasNext());
-    }
-
-    @Test
-    public void hasNextIfJustMoreXs() {
-        when(xs.hasNext()).thenReturn(true);
-        when(ys.hasNext()).thenReturn(false);
-
-        assertTrue(concatenatingIterator.hasNext());
-    }
-
-    @Test
-    public void hasNextIfJustMoreYs() {
-        when(xs.hasNext()).thenReturn(false);
-        when(ys.hasNext()).thenReturn(true);
-
-        assertTrue(concatenatingIterator.hasNext());
-    }
-
-    @Test
-    public void doesNotHaveNextIfNeitherMoreXsNorMoreYs() {
-        when(xs.hasNext()).thenReturn(false);
-        when(ys.hasNext()).thenReturn(false);
-
-        assertFalse(concatenatingIterator.hasNext());
-    }
-
-    @Test
-    public void nextPullsFromXsFirstThenFromYs() {
-        mockIteratorToHaveValues(xs, 1, 2);
-        mockIteratorToHaveValues(ys, 3);
-
-        assertThat(concatenatingIterator.hasNext(), is(true));
-        assertThat(concatenatingIterator.next(), is(1));
-        assertThat(concatenatingIterator.hasNext(), is(true));
-        assertThat(concatenatingIterator.next(), is(2));
-        assertThat(concatenatingIterator.hasNext(), is(true));
-        assertThat(concatenatingIterator.next(), is(3));
-        assertThat(concatenatingIterator.hasNext(), is(false));
-    }
-
-    @Test
-    public void stackSafety() {
-        Integer stackBlowingNumber = 50000;
-        Iterable<Iterable<Integer>> xss = map(Collections::singleton, take(stackBlowingNumber, iterate(x -> x + 1, 1)));
-        Iterable<Integer> deeplyNestedConcat = foldRight((xs, ys) -> () -> new ConcatenatingIterator<>(xs, ys),
-                                                         (Iterable<Integer>) Collections.<Integer>emptySet(),
-                                                         xss);
-
-        Iterable<Integer> ints = () -> new ConcatenatingIterator<>(deeplyNestedConcat, deeplyNestedConcat);
-
-        assertEquals(just(stackBlowingNumber), last(ints));
-        assertEquals((long) (stackBlowingNumber * 2), size(ints).longValue());
-    }
-}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/IsoTest.java b/src/test/java/com/jnape/palatable/lambda/lens/IsoTest.java
new file mode 100644
index 000000000..016de15ee
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/lens/IsoTest.java
@@ -0,0 +1,57 @@
+package com.jnape.palatable.lambda.lens;
+
+import com.jnape.palatable.lambda.adt.Maybe;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import testsupport.EqualityAwareIso;
+import testsupport.traits.ApplicativeLaws;
+import testsupport.traits.FunctorLaws;
+import testsupport.traits.MonadLaws;
+
+import java.util.List;
+
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.lens.Iso.iso;
+import static com.jnape.palatable.lambda.lens.functions.Set.set;
+import static com.jnape.palatable.lambda.lens.functions.View.view;
+import static java.util.Arrays.asList;
+import static java.util.stream.Collectors.toList;
+import static org.junit.Assert.assertEquals;
+
+@RunWith(Traits.class)
+public class IsoTest {
+
+    private static final Iso<String, List<Character>, Integer, Double> ISO =
+            iso(Integer::parseInt, dbl -> dbl.toString().chars().mapToObj(x -> (char) x).collect(toList()));
+
+    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class})
+    public Iso<String, List<Character>, Integer, Double> testSubject() {
+        return new EqualityAwareIso<>("123", 1.23d, ISO);
+    }
+
+    @Test
+    public void lensLike() {
+        assertEquals((Integer) 123, view(ISO, "123"));
+        assertEquals(asList('1', '.', '2', '3'), set(ISO, 1.23d, "234"));
+    }
+
+    @Test
+    public void mirrorFlipsIso() {
+        assertEquals(asList('1', '.', '2', '3'), view(ISO.mirror(), 1.23d));
+        assertEquals((Integer) 240, set(ISO.mirror(), "240", 5.67d));
+    }
+
+    @Test
+    public void mapsIndividuallyOverParameters() {
+        Iso<Maybe<String>, Maybe<List<Character>>, Maybe<Integer>, Maybe<Double>> mapped = ISO
+                .mapS((Maybe<String> maybeS) -> maybeS.orElse(""))
+                .mapT(Maybe::maybe)
+                .mapA(Maybe::maybe)
+                .mapB((Maybe<Double> maybeD) -> maybeD.orElse(-1d));
+
+        assertEquals(just(1), view(mapped, just("1")));
+        assertEquals(just(asList('1', '.', '2')), view(mapped.mirror(), just(1.2d)));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/LensTest.java b/src/test/java/com/jnape/palatable/lambda/lens/LensTest.java
index df8e40942..2ab9e8028 100644
--- a/src/test/java/com/jnape/palatable/lambda/lens/LensTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/lens/LensTest.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.lens;
 
 import com.jnape.palatable.lambda.adt.Maybe;
-import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functor.builtin.Const;
 import com.jnape.palatable.lambda.functor.builtin.Identity;
 import com.jnape.palatable.traitor.annotations.TestTraits;
@@ -18,7 +18,10 @@
 import java.util.Set;
 
 import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.lens.Lens.both;
 import static com.jnape.palatable.lambda.lens.Lens.lens;
+import static com.jnape.palatable.lambda.lens.Lens.simpleLens;
 import static com.jnape.palatable.lambda.lens.functions.Set.set;
 import static com.jnape.palatable.lambda.lens.functions.View.view;
 import static java.lang.Integer.parseInt;
@@ -52,17 +55,6 @@ public void viewsUnderConst() {
         assertEquals((Integer) 3, i);
     }
 
-    @Test
-    public void fix() {
-        Fn1<String, Const<Integer, Integer>> fn = s -> new Const<>(s.length());
-        List<String> s = singletonList("foo");
-
-        Integer fixedLensResult = LENS.<Const<Integer, ?>, Const<Integer, Set<Integer>>, Const<Integer, Integer>>fix().apply(fn, s).runConst();
-        Integer unfixedLensResult = LENS.<Const<Integer, ?>, Const<Integer, Set<Integer>>, Const<Integer, Integer>>apply(fn, s).runConst();
-
-        assertEquals(unfixedLensResult, fixedLensResult);
-    }
-
     @Test
     public void mapsIndividuallyOverParameters() {
         Lens<String, Boolean, Character, Integer> lens = lens(s -> s.charAt(0), (s, b) -> s.length() == b);
@@ -72,8 +64,11 @@ public void mapsIndividuallyOverParameters() {
                 .mapA(Maybe::maybe)
                 .mapB((Maybe<Integer> maybeI) -> maybeI.orElse(-1));
 
-        Lens.Fixed<Maybe<String>, Maybe<Boolean>, Maybe<Character>, Maybe<Integer>, Identity, Identity<Maybe<Boolean>>, Identity<Maybe<Integer>>> fixed = theGambit.fix();
-        assertEquals(just(true), fixed.apply(maybeC -> new Identity<>(maybeC.fmap(c -> parseInt(Character.toString(c)))), just("321")).runIdentity());
+        assertEquals(just(true),
+                     theGambit.<Identity, Identity<Maybe<Boolean>>, Identity<Maybe<Integer>>>apply(
+                             maybeC -> new Identity<>(maybeC.fmap(c -> parseInt(Character.toString(c)))),
+                             just("321")).runIdentity()
+        );
     }
 
     @Test
@@ -89,4 +84,23 @@ public void andThenComposesInReverse() {
         assertEquals("one", view(EARLIER_LENS.andThen(LENS), map));
         assertEquals(singletonMap("foo", singleton(1)), set(EARLIER_LENS.andThen(LENS), 1, map));
     }
+
+    @Test
+    public void bothSplitsFocusBetweenLenses() {
+        Lens<String, String, Character, Character> firstChar = simpleLens(s -> s.charAt(0), (s, c) -> c + s.substring(1));
+        Lens<String, String, Integer, Integer> length = simpleLens(String::length, (s, k) -> s.substring(0, k));
+        Lens<String, String, Tuple2<Character, Integer>, Tuple2<Character, Integer>> both = both(firstChar, length);
+
+        assertEquals(tuple('a', 3), view(both, "abc"));
+        assertEquals("zb", set(both, tuple('z', 2), "abc"));
+    }
+
+    @Test
+    public void bothForSimpleLenses() {
+        Lens.Simple<String, Integer> stringToInt = simpleLens(Integer::parseInt, (s, i) -> s + i.toString());
+        Lens.Simple<String, Character> stringToChar = simpleLens(s -> s.charAt(0), (s, c) -> s + c.toString());
+
+        assertEquals(tuple(3, '3'), view(both(stringToInt, stringToChar), "3"));
+        assertEquals("133", set(both(stringToInt, stringToChar), tuple(3, '3'), "1"));
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/functions/UnderTest.java b/src/test/java/com/jnape/palatable/lambda/lens/functions/UnderTest.java
new file mode 100644
index 000000000..58d44f19f
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/lens/functions/UnderTest.java
@@ -0,0 +1,22 @@
+package com.jnape.palatable.lambda.lens.functions;
+
+import com.jnape.palatable.lambda.lens.Iso;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static com.jnape.palatable.lambda.lens.Iso.iso;
+import static com.jnape.palatable.lambda.lens.functions.Under.under;
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+
+public class UnderTest {
+
+    @Test
+    public void reversesTypeRingWalk() {
+        Iso<List<String>, Set<Integer>, String, Integer> iso = iso(xs -> xs.get(0), Collections::singleton);
+        assertEquals("1", under(iso, set -> singletonList(set.iterator().next().toString()), 1));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/lenses/HMapLensTest.java b/src/test/java/com/jnape/palatable/lambda/lens/lenses/HMapLensTest.java
new file mode 100644
index 000000000..66073427e
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/lens/lenses/HMapLensTest.java
@@ -0,0 +1,30 @@
+package com.jnape.palatable.lambda.lens.lenses;
+
+import com.jnape.palatable.lambda.adt.hmap.TypeSafeKey;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.hmap.HMap.emptyHMap;
+import static com.jnape.palatable.lambda.adt.hmap.HMap.hMap;
+import static com.jnape.palatable.lambda.adt.hmap.HMap.singletonHMap;
+import static com.jnape.palatable.lambda.adt.hmap.TypeSafeKey.typeSafeKey;
+import static java.util.Arrays.asList;
+import static testsupport.assertion.LensAssert.assertLensLawfulness;
+
+public class HMapLensTest {
+
+    @Test
+    public void valueAt() {
+        TypeSafeKey.Simple<String> key = typeSafeKey();
+        assertLensLawfulness(HMapLens.valueAt(key),
+                             asList(emptyHMap(),
+                                    singletonHMap(key, "foo"),
+                                    hMap(key, "foo",
+                                         typeSafeKey(), "bar"),
+                                    singletonHMap(typeSafeKey(), "bar")),
+                             asList(nothing(),
+                                    just("foo"),
+                                    just("bar")));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/lenses/MapLensTest.java b/src/test/java/com/jnape/palatable/lambda/lens/lenses/MapLensTest.java
index aceb8c626..dc18edd90 100644
--- a/src/test/java/com/jnape/palatable/lambda/lens/lenses/MapLensTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/lens/lenses/MapLensTest.java
@@ -10,6 +10,7 @@
 
 import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.lens.Iso.iso;
 import static com.jnape.palatable.lambda.lens.functions.Set.set;
 import static com.jnape.palatable.lambda.lens.functions.View.view;
 import static com.jnape.palatable.lambda.lens.lenses.MapLens.keys;
@@ -136,25 +137,21 @@ public void invertedFocusesOnMapWithKeysAndValuesSwitched() {
     }
 
     @Test
-    public void mappingValuesRetainsMapStructureWithMappedValues() {
-        Map<String, String> m = unmodifiableMap(new HashMap<String, String>() {{
-            put("foo", "1");
-            put("bar", "2");
-            put("baz", "3");
-        }});
-        Lens.Simple<Map<String, String>, Map<String, Integer>> mappingValues = mappingValues(Integer::parseInt);
-
-        assertEquals(new HashMap<String, Integer>() {{
-            put("foo", 1);
-            put("bar", 2);
-            put("baz", 3);
-        }}, view(mappingValues, m));
-
-        Map<String, String> updated = set(mappingValues, unmodifiableMap(new HashMap<String, Integer>() {{
-            put("foo", 2);
-            put("bar", 1);
-            put("baz", 3);
-        }}), m);
-        assertEquals(singletonMap("baz", "3"), updated);
+    public void mappingValuesWithIsoRetainsMapStructureWithMappedValues() {
+        assertLensLawfulness(mappingValues(iso(Integer::parseInt, Object::toString)),
+                             asList(emptyMap(),
+                                    singletonMap("foo", "1"),
+                                    unmodifiableMap(new HashMap<String, String>() {{
+                                        put("foo", "1");
+                                        put("bar", "2");
+                                        put("baz", "3");
+                                    }})),
+                             asList(emptyMap(),
+                                    singletonMap("foo", 1),
+                                    unmodifiableMap(new HashMap<String, Integer>() {{
+                                        put("foo", 1);
+                                        put("bar", 2);
+                                        put("baz", 3);
+                                    }})));
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/monoid/builtin/PutAllTest.java b/src/test/java/com/jnape/palatable/lambda/monoid/builtin/PutAllTest.java
index fc5500ac5..bd664b01d 100644
--- a/src/test/java/com/jnape/palatable/lambda/monoid/builtin/PutAllTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/monoid/builtin/PutAllTest.java
@@ -19,8 +19,8 @@ public void identity() {
 
     @Test
     public void monoid() {
-        TypeSafeKey<String> stringKey = typeSafeKey();
-        TypeSafeKey<Integer> intKey = typeSafeKey();
+        TypeSafeKey<String, String> stringKey = typeSafeKey();
+        TypeSafeKey<Integer, Integer> intKey = typeSafeKey();
 
         HMap x = singletonHMap(stringKey, "string");
         HMap y = singletonHMap(intKey, 1);
diff --git a/src/test/java/com/jnape/palatable/lambda/traversable/TraversableTest.java b/src/test/java/com/jnape/palatable/lambda/traversable/TraversableTest.java
new file mode 100644
index 000000000..f27c2b214
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/traversable/TraversableTest.java
@@ -0,0 +1,31 @@
+package com.jnape.palatable.lambda.traversable;
+
+import com.jnape.palatable.lambda.adt.Either;
+import com.jnape.palatable.lambda.adt.Maybe;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.adt.Either.right;
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+public class TraversableTest {
+
+    @Test
+    public void compilation() {
+        Either<String, Maybe<Integer>> a = just(Either.<String, Integer>right(1)).traverse(id(), Either::right);
+        assertEquals(right(just(1)), a);
+
+        Maybe<Either<String, Integer>> b = Either.<String, Maybe<Integer>>right(just(1)).traverse(id(), Maybe::just);
+        assertEquals(just(right(1)), b);
+
+        Either<String, Maybe<Integer>> c = b.traverse(id(), Either::right);
+        assertEquals(a, c);
+
+        Maybe<LambdaIterable<Integer>> d = LambdaIterable.wrap(asList(just(1), just(2))).traverse(id(), Maybe::just);
+        assertThat(d.orElseThrow(AssertionError::new).unwrap(), iterates(1, 2));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/testsupport/EqualityAwareIso.java b/src/test/java/testsupport/EqualityAwareIso.java
new file mode 100644
index 000000000..0efc7f039
--- /dev/null
+++ b/src/test/java/testsupport/EqualityAwareIso.java
@@ -0,0 +1,72 @@
+package testsupport;
+
+import com.jnape.palatable.lambda.functor.Applicative;
+import com.jnape.palatable.lambda.functor.Functor;
+import com.jnape.palatable.lambda.functor.Profunctor;
+import com.jnape.palatable.lambda.lens.Iso;
+import com.jnape.palatable.lambda.lens.LensLike;
+import com.jnape.palatable.lambda.monad.Monad;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Both.both;
+import static com.jnape.palatable.lambda.lens.functions.View.view;
+
+public final class EqualityAwareIso<S, T, A, B> implements Iso<S, T, A, B> {
+    private final S               s;
+    private final B               b;
+    private final Iso<S, T, A, B> iso;
+
+    public EqualityAwareIso(S s, B b, Iso<S, T, A, B> iso) {
+        this.s = s;
+        this.b = b;
+        this.iso = iso;
+    }
+
+    @Override
+    public <P extends Profunctor, F extends Functor, FB extends Functor<B, F>, FT extends Functor<T, F>, PAFB extends Profunctor<A, FB, P>, PSFT extends Profunctor<S, FT, P>> PSFT apply(
+            PAFB pafb) {
+        return iso.<P, F, FB, FT, PAFB, PSFT>apply(pafb);
+    }
+
+    @Override
+    public <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> FT apply(
+            Function<? super A, ? extends FB> fn, S s) {
+        return iso.apply(fn, s);
+    }
+
+    @Override
+    public <U> EqualityAwareIso<S, U, A, B> fmap(Function<? super T, ? extends U> fn) {
+        return new EqualityAwareIso<>(s, b, iso.fmap(fn));
+    }
+
+    @Override
+    public <U> EqualityAwareIso<S, U, A, B> pure(U u) {
+        return new EqualityAwareIso<>(s, b, iso.pure(u));
+    }
+
+    @Override
+    public <U> EqualityAwareIso<S, U, A, B> zip(
+            Applicative<Function<? super T, ? extends U>, LensLike<S, ?, A, B, Iso>> appFn) {
+        return new EqualityAwareIso<>(s, b, iso.zip(appFn));
+    }
+
+    @Override
+    public <U> EqualityAwareIso<S, U, A, B> flatMap(
+            Function<? super T, ? extends Monad<U, LensLike<S, ?, A, B, Iso>>> fn) {
+        return new EqualityAwareIso<>(s, b, iso.flatMap(fn));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean equals(Object other) {
+        if (other instanceof EqualityAwareIso) {
+            Iso<S, T, A, B> that = (EqualityAwareIso<S, T, A, B>) other;
+            Boolean sameForward = both(view(this), view(that)).apply(s).into(Objects::equals);
+            Boolean sameReverse = both(view(this.mirror()), view(that.mirror())).apply(b).into(Objects::equals);
+            return sameForward && sameReverse;
+        }
+        return false;
+    }
+}
diff --git a/src/test/java/testsupport/EqualityAwareLens.java b/src/test/java/testsupport/EqualityAwareLens.java
index f70f96c37..e8a8cb52f 100644
--- a/src/test/java/testsupport/EqualityAwareLens.java
+++ b/src/test/java/testsupport/EqualityAwareLens.java
@@ -4,6 +4,7 @@
 import com.jnape.palatable.lambda.functor.Functor;
 import com.jnape.palatable.lambda.functor.builtin.Const;
 import com.jnape.palatable.lambda.lens.Lens;
+import com.jnape.palatable.lambda.lens.LensLike;
 import com.jnape.palatable.lambda.monad.Monad;
 
 import java.util.Objects;
@@ -25,7 +26,8 @@ public <F extends Functor, FT extends Functor<T, F>, FB extends Functor<B, F>> F
     }
 
     @Override
-    public <U> EqualityAwareLens<S, U, A, B> flatMap(Function<? super T, ? extends Monad<U, Lens<S, ?, A, B>>> f) {
+    public <U> EqualityAwareLens<S, U, A, B> flatMap(
+            Function<? super T, ? extends Monad<U, LensLike<S, ?, A, B, Lens>>> f) {
         return new EqualityAwareLens<>(s, lens.flatMap(f));
     }
 
@@ -41,7 +43,7 @@ public <U> EqualityAwareLens<S, U, A, B> pure(U u) {
 
     @Override
     public <U> EqualityAwareLens<S, U, A, B> zip(
-            Applicative<Function<? super T, ? extends U>, Lens<S, ?, A, B>> appFn) {
+            Applicative<Function<? super T, ? extends U>, LensLike<S, ?, A, B, Lens>> appFn) {
         return new EqualityAwareLens<>(s, lens.zip(appFn));
     }
 
diff --git a/src/test/java/testsupport/assertion/LensAssert.java b/src/test/java/testsupport/assertion/LensAssert.java
index 3f2e80ae8..e89678afb 100644
--- a/src/test/java/testsupport/assertion/LensAssert.java
+++ b/src/test/java/testsupport/assertion/LensAssert.java
@@ -4,7 +4,7 @@
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.builtin.fn2.Map;
-import com.jnape.palatable.lambda.lens.Lens;
+import com.jnape.palatable.lambda.lens.LensLike;
 import com.jnape.palatable.lambda.monoid.builtin.Present;
 
 import java.util.Objects;
@@ -23,7 +23,7 @@
 
 public final class LensAssert {
 
-    public static <S, A> void assertLensLawfulness(Lens<S, S, A, A> lens, Iterable<S> ss, Iterable<A> bs) {
+    public static <S, A> void assertLensLawfulness(LensLike<S, S, A, A, ?> lens, Iterable<S> ss, Iterable<A> bs) {
         Iterable<Tuple2<S, A>> cases = cartesianProduct(ss, bs);
         Present.<String>present((x, y) -> join("\n\n", x, y))
                 .reduceLeft(asList(falsify("You get back what you put in", (s, b) -> view(lens, set(lens, b, s)), (s, b) -> b, cases),
@@ -37,7 +37,7 @@ private static <S, A, X> Maybe<String> falsify(String label, Fn2<S, A, X> l, Fn2
         return Map.<Tuple2<S, A>, Maybe<String>>map(into((s, b) -> {
             X x = l.apply(s, b);
             X y = r.apply(s, b);
-            return Objects.equals(x, y)  ? nothing() : just(format("S <%s>, B <%s> (%s != %s)", s, b, x, y));
+            return Objects.equals(x, y) ? nothing() : just(format("S <%s>, B <%s> (%s != %s)", s, b, x, y));
         }))
                 .fmap(catMaybes())
                 .fmap(reduceLeft((x, y) -> x + "\n\t - " + y))
diff --git a/src/test/java/testsupport/traits/Deforesting.java b/src/test/java/testsupport/traits/Deforesting.java
new file mode 100644
index 000000000..cb38b87ef
--- /dev/null
+++ b/src/test/java/testsupport/traits/Deforesting.java
@@ -0,0 +1,15 @@
+package testsupport.traits;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.traits.Trait;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.Times.times;
+
+public final class Deforesting implements Trait<Fn1<Iterable<?>, Iterable<?>>> {
+
+    @Override
+    public void test(Fn1<Iterable<?>, Iterable<?>> fn) {
+        times(10_000, fn, repeat(1)).iterator().next();
+    }
+}
diff --git a/src/test/java/testsupport/traits/TraversableLaws.java b/src/test/java/testsupport/traits/TraversableLaws.java
index a7d15fbd8..8ce0ab0f0 100644
--- a/src/test/java/testsupport/traits/TraversableLaws.java
+++ b/src/test/java/testsupport/traits/TraversableLaws.java
@@ -60,7 +60,7 @@ private Maybe<String> testComposition(Traversable<?, Trav> trav) {
         Function<Object, Applicative<Object, Identity>> g = x -> new Identity<>(x);
 
         return trav.traverse(f.andThen(x -> x.fmap(g)).andThen(Compose::new), x -> new Compose<>(new Identity<>(new Identity<>(x))))
-                .equals(new Compose<Identity, Identity, Traversable<Object, Trav>>(trav.traverse(f, x -> new Identity<>(x)).fmap(t -> t.traverse(g, x -> new Identity<>(x)))))
+                       .equals(new Compose<>(trav.traverse(f, x -> new Identity<>(x)).fmap(t -> t.traverse(g, x -> new Identity<>(x)))))
                 ? nothing()
                 : just("compose (trav.traverse(f.andThen(x -> x.fmap(g)).andThen(Compose::new), x -> new Compose<>(new Identity<>(new Identity<>(x))))\n" +
                                "                .equals(new Compose<Identity, Identity, Traversable<Object, Trav>>(trav.traverse(f, x -> new Identity<>(x)).fmap(t -> t.traverse(g, x -> new Identity<>(x))))))");