diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56605e5a8..26b2fe0a8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,29 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## [Unreleased]
 ### Fixed
+- `ConcatenatingIterator` bug where deeply nested `xs` skip elements
+
+### Deprecated
+- `Fn1#then` in favor of `Fn1#andThen` (redundant)
+- `Fn1#adapt` in favor of `Fn1#fn1` (rename)
+- `Fn2#adapt` in favor of `Fn2#fn2` (rename)
+
+### Changed
+- Loosening variance on `Fn2#fn2` and `Fn1#fn1`
+
+### Added
+- `Fn1#andThen` overload to support composition with `Bifunction`
+- `Fn1#compose` overload to support composition with `Bifunction` and `Fn2`
+- `LiftA2` to lift and apply a `Bifunction` to two `Applicative`s
+- `Flatten` to lazily flatten nested `Iterable<Iterable<A>>`s to `Iterable<A>`
+- `Replicate`, short-hand composition of `take` and `repeat`
+- `Distinct` to produce an `Iterable` of distinct values in another `Iterable`
+- `Sort` and `SortBy` for eagerly, monolithically sorting `Iterable`s and producing `List`s  
+- `IterableLens`, general lenses over `Iterable`
+- `Xor`, a monoid representing logical exclusive-or
+
+## [1.6.2] - 2017-08-20
+### Fixed
 - ClassCastException `BiPredicate.flip` 
 
 ### Added
@@ -137,7 +160,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-1.6.1...HEAD
+[Unreleased]: https://github.com/palatable/lambda/compare/lambda-1.6.2...HEAD
+[1.6.2]: https://github.com/palatable/lambda/compare/lambda-1.6.1...lambda-1.6.2
 [1.6.1]: https://github.com/palatable/lambda/compare/lambda-1.6.0...lambda-1.6.1
 [1.6.0]: https://github.com/palatable/lambda/compare/lambda-1.5.6...lambda-1.6.0
 [1.5.6]: https://github.com/palatable/lambda/compare/lambda-1.5.5...lambda-1.5.6
diff --git a/README.md b/README.md
index 83d52c923..e34a5ab7f 100644
--- a/README.md
+++ b/README.md
@@ -55,14 +55,14 @@ Add the following dependency to your:
 <dependency>
     <groupId>com.jnape.palatable</groupId>
     <artifactId>lambda</artifactId>
-    <version>1.6.1</version>
+    <version>1.6.2</version>
 </dependency>
 ```
 
 `build.gradle` ([Gradle](https://docs.gradle.org/current/userguide/dependency_management.html)):
 
 ```gradle
-compile group: 'com.jnape.palatable', name: 'lambda', version: '1.6.1'
+compile group: 'com.jnape.palatable', name: 'lambda', version: '1.6.2'
 ```
 
 <a name="examples">Examples</a>
@@ -81,8 +81,8 @@ Every function in lambda is [curried](https://www.wikiwand.com/en/Currying), so
 ```Java
 Fn1<Iterable<Integer>, Integer> sumOfEvenIncrementsFn =
           map((Integer x) -> x + 1)
-          .then(filter(x -> x % 2 == 0))
-          .then(reduceLeft((x, y) -> x + y));
+          .andThen(filter(x -> x % 2 == 0))
+          .andThen(reduceLeft((x, y) -> x + y));
 
 Integer sumOfEvenIncrements = sumOfEvenIncrementsFn.apply(asList(1, 2, 3, 4, 5));
 //-> 12
@@ -120,7 +120,7 @@ Let's compose two functions:
 Fn1<Integer, Integer> add = x -> x + 1;
 Fn1<Integer, Integer> subtract = x -> x -1;
 
-Fn1<Integer, Integer> noOp = add.then(subtract);
+Fn1<Integer, Integer> noOp = add.andThen(subtract);
 // same as
 Fn1<Integer, Integer> alsoNoOp = subtract.compose(add);
 ```
diff --git a/pom.xml b/pom.xml
index 05fcf0ab9..a58b8340f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,7 +9,7 @@
     </parent>
 
     <artifactId>lambda</artifactId>
-    <version>1.6.2</version>
+    <version>1.6.3</version>
     <packaging>jar</packaging>
 
     <name>Lambda</name>
@@ -48,7 +48,7 @@
         <developer>
             <id>jnape</id>
             <name>John Napier</name>
-            <email>john@jnape.com</email>
+            <email>jnape09@gmail.com</email>
         </developer>
     </developers>
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
index 8d24de2b4..fb1b7f27e 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
@@ -3,8 +3,11 @@
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Profunctor;
 
+import java.util.function.BiFunction;
 import java.util.function.Function;
 
+import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+
 /**
  * A function taking a single argument. This is the core function type that all other function types extend and
  * auto-curry with.
@@ -30,7 +33,9 @@ public interface Fn1<A, B> extends Applicative<B, Fn1<A, ?>>, Profunctor<A, B, F
      * @param f   the function to invoke with this function's return value
      * @param <C> the return type of the next function to invoke
      * @return a function representing the composition of this function and f
+     * @deprecated in favor of {@link Fn1#andThen(Function)}
      */
+    @Deprecated
     default <C> Fn1<A, C> then(Function<? super B, ? extends C> f) {
         return fmap(f);
     }
@@ -41,34 +46,47 @@ default <C> Fn1<A, C> then(Function<? super B, ? extends C> f) {
      * @param <C> the return type of the next function to invoke
      * @param f   the function to invoke with this function's return value
      * @return a function representing the composition of this function and f
-     * @see Fn1#then(Function)
      */
     @Override
-    @SuppressWarnings("unchecked")
     default <C> Fn1<A, C> fmap(Function<? super B, ? extends C> f) {
-        return (Fn1<A, C>) Applicative.super.fmap(f);
+        return Applicative.super.<C>fmap(f).coerce();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     default <C> Fn1<A, C> pure(C c) {
         return __ -> c;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     default <C> Fn1<A, C> zip(Applicative<Function<? super B, ? extends C>, Fn1<A, ?>> appFn) {
         return a -> appFn.<Fn1<A, Function<? super B, ? extends C>>>coerce().apply(a).apply(apply(a));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @SuppressWarnings("unchecked")
     default <C> Fn1<A, C> zip(Fn2<A, B, C> appFn) {
         return zip((Fn1<A, Function<? super B, ? extends C>>) (Object) appFn);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     default <C> Fn1<A, C> discardL(Applicative<C, Fn1<A, ?>> appB) {
         return Applicative.super.discardL(appB).coerce();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     default <C> Fn1<A, B> discardR(Applicative<C, Fn1<A, ?>> appB) {
         return Applicative.super.discardR(appB).coerce();
@@ -127,6 +145,44 @@ default <Z> Fn1<Z, B> compose(Function<? super Z, ? extends A> before) {
         return z -> apply(before.apply(z));
     }
 
+    /**
+     * Right-to-left composition between different arity functions. Preserves highest arity in the return type,
+     * specialized to lambda types (in this case, {@link BiFunction} -&gt; {@link Fn2}).
+     *
+     * @param before the function to pass its return value to this function's input
+     * @param <Y>    the resulting function's first argument type
+     * @param <Z>    the resulting function's second argument type
+     * @return a new function from Y x Z to B
+     */
+    default <Y, Z> Fn2<Y, Z, B> compose(BiFunction<? super Y, ? super Z, ? extends A> before) {
+        return compose(fn2(before));
+    }
+
+    /**
+     * Right-to-left composition between different arity functions. Preserves highest arity in the return type.
+     *
+     * @param before the function to pass its return value to this function's input
+     * @param <Y>    the resulting function's first argument type
+     * @param <Z>    the resulting function's second argument type
+     * @return a new function from Y x Z to B
+     */
+    default <Y, Z> Fn2<Y, Z, B> compose(Fn2<? super Y, ? super Z, ? extends A> before) {
+        return fn2(before.fmap(this::compose))::apply;
+    }
+
+    /**
+     * Left-to-right composition between different arity functions. Preserves highest arity in the return type,
+     * specialized to lambda types (in this case, {@link BiFunction} -&gt; {@link Fn2}).
+     *
+     * @param after the function to invoke on this function's return value
+     * @param <C>   the resulting function's second argument type
+     * @param <D>   the resulting function's return type
+     * @return a new function from A x C to D
+     */
+    default <C, D> Fn2<A, C, D> andThen(BiFunction<? super B, ? super C, ? extends D> after) {
+        return (a, c) -> after.apply(apply(a), c);
+    }
+
     /**
      * Override of {@link Function#andThen(Function)}, returning an instance of <code>Fn1</code> for compatibility.
      * Left-to-right composition.
@@ -148,8 +204,23 @@ default <C> Fn1<A, C> andThen(Function<? super B, ? extends C> after) {
      * @param <A>      the input argument type
      * @param <B>      the output type
      * @return the Fn1
+     * @deprecated in favor of {@link Fn1#fn1(Function)}
      */
+    @Deprecated
     static <A, B> Fn1<A, B> adapt(Function<A, B> function) {
         return function::apply;
     }
+
+    /**
+     * Static factory method for wrapping a {@link Function} in an {@link Fn1}. Useful for avoid explicit casting when
+     * using method references as {@link Fn1}s.
+     *
+     * @param function the function to adapt
+     * @param <A>      the input argument type
+     * @param <B>      the output type
+     * @return the Fn1
+     */
+    static <A, B> Fn1<A, B> fn1(Function<? super A, ? extends B> function) {
+        return function::apply;
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
index c449fb2aa..3855e6caa 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
@@ -3,6 +3,7 @@
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 
 import java.util.function.BiFunction;
+import java.util.function.Function;
 
 /**
  * A function taking two arguments. Note that defining <code>Fn2</code> in terms of <code>Fn1</code> provides a
@@ -26,6 +27,18 @@ public interface Fn2<A, B, C> extends Fn1<A, Fn1<B, C>> {
      */
     C apply(A a, B b);
 
+    /**
+     * Same as normal composition, except that the result is an instance of <code>Fn2</code> for convenience.
+     *
+     * @param before the function who's return value is this function's argument
+     * @param <Z>    the new argument type
+     * @return a new Fn2&lt;Z,B,C&gt;
+     */
+    @Override
+    default <Z> Fn2<Z, B, C> compose(Function<? super Z, ? extends A> before) {
+        return fn2(Fn1.super.compose(before));
+    }
+
     /**
      * Partially apply this function by passing its first argument.
      *
@@ -74,8 +87,37 @@ default BiFunction<A, B, C> toBiFunction() {
      * @param <B>        the second input argument type
      * @param <C>        the output type
      * @return the Fn2
+     * @deprecated in favor of {@link Fn2#fn2(BiFunction)}
      */
+    @Deprecated
     static <A, B, C> Fn2<A, B, C> adapt(BiFunction<A, B, C> biFunction) {
         return biFunction::apply;
     }
+
+    /**
+     * Static factory method for wrapping a {@link BiFunction} in an {@link Fn2}. Useful for avoid explicit casting when
+     * using method references as {@link Fn2}s.
+     *
+     * @param biFunction the biFunction to adapt
+     * @param <A>        the first input argument type
+     * @param <B>        the second input argument type
+     * @param <C>        the output type
+     * @return the Fn2
+     */
+    static <A, B, C> Fn2<A, B, C> fn2(BiFunction<? super A, ? super B, ? extends C> biFunction) {
+        return biFunction::apply;
+    }
+
+    /**
+     * Static factory method for wrapping a curried {@link Fn1} in an {@link Fn2}.
+     *
+     * @param curriedFn1 the curried fn1 to adapt
+     * @param <A>        the first input argument type
+     * @param <B>        the second input argument type
+     * @param <C>        the output type
+     * @return the Fn2
+     */
+    static <A, B, C> Fn2<A, B, C> fn2(Fn1<A, Fn1<B, C>> curriedFn1) {
+        return (a, b) -> curriedFn1.apply(a).apply(b);
+    }
 }
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
new file mode 100644
index 000000000..197f90abd
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Distinct.java
@@ -0,0 +1,34 @@
+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;
+
+/**
+ * Return an {@link Iterable} of the distinct values from the given input {@link Iterable}.
+ *
+ * @param <A> the Iterable element type
+ */
+public final class Distinct<A> implements Fn1<Iterable<A>, Iterable<A>> {
+    private static final Distinct INSTANCE = new Distinct();
+
+    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);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Distinct<A> distinct() {
+        return INSTANCE;
+    }
+
+    public static <A> Iterable<A> distinct(Iterable<A> as) {
+        return Distinct.<A>distinct().apply(as);
+    }
+}
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
new file mode 100644
index 000000000..0bb35e775
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Flatten.java
@@ -0,0 +1,31 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.iterators.FlatteningIterator;
+
+/**
+ * Given a nested {@link Iterable} of {@link Iterable}s, return a lazily flattening {@link Iterable}
+ * of the nested elements.
+ *
+ * @param <A> the nested Iterable element type
+ */
+public final class Flatten<A> implements Fn1<Iterable<? extends Iterable<? extends A>>, Iterable<A>> {
+    private static final Flatten INSTANCE = new Flatten();
+
+    private Flatten() {
+    }
+
+    @Override
+    public Iterable<A> apply(Iterable<? extends Iterable<? extends A>> iterables) {
+        return () -> new FlatteningIterator<>(iterables.iterator());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Flatten<A> flatten() {
+        return INSTANCE;
+    }
+
+    public static <A> Iterable<A> flatten(Iterable<? extends Iterable<? extends A>> as) {
+        return Flatten.<A>flatten().apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Sort.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Sort.java
new file mode 100644
index 000000000..ce297dd9b
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Sort.java
@@ -0,0 +1,37 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+
+import java.util.List;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.SortBy.sortBy;
+
+/**
+ * Given an {@link Iterable} of {@link Comparable} elements, return a {@link List} of the sorted elements. Note that
+ * this is both eager and monolithic.
+ *
+ * @param <A> the input Iterable and output List element type
+ * @see com.jnape.palatable.lambda.functions.builtin.fn2.SortBy
+ */
+public final class Sort<A extends Comparable<A>> implements Fn1<Iterable<A>, List<A>> {
+
+    private static final Sort INSTANCE = new Sort();
+
+    private Sort() {
+    }
+
+    @Override
+    public List<A> apply(Iterable<A> as) {
+        return sortBy(id(), as);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A extends Comparable<A>> Sort<A> sort() {
+        return INSTANCE;
+    }
+
+    public static <A extends Comparable<A>> List<A> sort(Iterable<A> as) {
+        return Sort.<A>sort().apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Replicate.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Replicate.java
new file mode 100644
index 000000000..5e08d92dc
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Replicate.java
@@ -0,0 +1,38 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
+
+/**
+ * Produce an {@link Iterable} of a value <code>n</code> times.
+ *
+ * @param <A> the output Iterable element type
+ */
+public final class Replicate<A> implements Fn2<Integer, A, Iterable<A>> {
+
+    public static final Replicate INSTANCE = new Replicate();
+
+    private Replicate() {
+    }
+
+    @Override
+    public Iterable<A> apply(Integer n, A a) {
+        return take(n, repeat(a));
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Replicate<A> replicate() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<A, Iterable<A>> replicate(Integer n) {
+        return Replicate.<A>replicate().apply(n);
+    }
+
+    public static <A> Iterable<A> replicate(Integer n, A a) {
+        return Replicate.<A>replicate(n).apply(a);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortBy.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortBy.java
new file mode 100644
index 000000000..de395356d
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortBy.java
@@ -0,0 +1,49 @@
+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.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ToCollection.toCollection;
+import static java.util.Comparator.comparing;
+
+/**
+ * Given an {@link Iterable} and some mapping function from the {@link Iterable} element type to some
+ * {@link Comparable} type, produce a sorted {@link List} of the original elements based on sorting applied to the
+ * result of the mapping function. Note that this is both eager and monolithic.
+ *
+ * @param <A> the input Iterable and output List element type
+ * @param <B> the mapped Comparable type
+ * @see com.jnape.palatable.lambda.functions.builtin.fn1.Sort
+ */
+public final class SortBy<A, B extends Comparable<B>> implements Fn2<Function<? super A, ? extends B>, Iterable<A>, List<A>> {
+
+    private static final SortBy INSTANCE = new SortBy();
+
+    private SortBy() {
+    }
+
+    @Override
+    public List<A> apply(Function<? super A, ? extends B> fn, Iterable<A> as) {
+        List<A> result = toCollection(ArrayList::new, as);
+        result.sort(comparing(fn));
+        return result;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A, B extends Comparable<B>> SortBy<A, B> sortBy() {
+        return INSTANCE;
+    }
+
+    public static <A, B extends Comparable<B>> Fn1<Iterable<A>, List<A>> sortBy(
+            Function<? super A, ? extends B> fn) {
+        return SortBy.<A, B>sortBy().apply(fn);
+    }
+
+    public static <A, B extends Comparable<B>> List<A> sortBy(Function<? super A, ? extends B> fn, Iterable<A> as) {
+        return SortBy.<A, B>sortBy(fn).apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2.java
new file mode 100644
index 000000000..c3dd1742b
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2.java
@@ -0,0 +1,56 @@
+package com.jnape.palatable.lambda.functions.builtin.fn3;
+
+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.functor.Applicative;
+
+import java.util.function.BiFunction;
+
+import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+
+/**
+ * Lift into and apply a {@link BiFunction} to two {@link Applicative} values, returning the result inside the same
+ * {@link Applicative} context. Equivalent ot <code>appB.zip(appA.fmap(fn))</code>.
+ *
+ * @param <A>   the function's first argument type
+ * @param <B>   the function's second argument type
+ * @param <C>   the function's return type
+ * @param <App> the applicative unification type
+ * @see Applicative#zip(Applicative)
+ */
+public final class LiftA2<A, B, C, App extends Applicative> implements Fn3<BiFunction<? super A, ? super B, ? extends C>,
+        Applicative<A, App>, Applicative<B, App>, Applicative<C, App>> {
+
+    private static final LiftA2 INSTANCE = new LiftA2();
+
+    private LiftA2() {
+    }
+
+    @Override
+    public Applicative<C, App> apply(BiFunction<? super A, ? super B, ? extends C> fn,
+                                     Applicative<A, App> appA,
+                                     Applicative<B, App> appB) {
+        return appB.zip(appA.fmap(fn2(fn)));
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A, B, C, App extends Applicative> LiftA2<A, B, C, App> liftA2() {
+        return INSTANCE;
+    }
+
+    public static <A, B, C, App extends Applicative> Fn2<Applicative<A, App>, Applicative<B, App>, Applicative<C, App>> liftA2(
+            BiFunction<? super A, ? super B, ? extends C> fn) {
+        return LiftA2.<A, B, C, App>liftA2().apply(fn);
+    }
+
+    public static <A, B, C, App extends Applicative> Fn1<Applicative<B, App>, Applicative<C, App>> liftA2(
+            BiFunction<? super A, ? super B, ? extends C> fn, Applicative<A, App> appA) {
+        return LiftA2.<A, B, C, App>liftA2(fn).apply(appA);
+    }
+
+    public static <A, B, C, App extends Applicative> Applicative<C, App> liftA2(
+            BiFunction<? super A, ? super B, ? extends C> fn, Applicative<A, App> appA, Applicative<B, App> appB) {
+        return LiftA2.<A, B, C, App>liftA2(fn, appA).apply(appB);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ConcatenatingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/ConcatenatingIterator.java
index 0191fd58a..cd58f6f74 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ConcatenatingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/ConcatenatingIterator.java
@@ -1,39 +1,40 @@
 package com.jnape.palatable.lambda.iterators;
 
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.NoSuchElementException;
-import java.util.Queue;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
 
 public class ConcatenatingIterator<A> implements Iterator<A> {
 
-    private final Iterable<A>                  xs;
-    private final Iterable<A>                  ys;
+    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 final Queue<Iterable<A>>           afterXs;
-    private final Queue<Iterable<A>>           afterYs;
+    private       boolean                      iteratedXs;
 
     public ConcatenatingIterator(Iterable<A> xs, Iterable<A> ys) {
-        this.xs = xs;
-        this.ys = ys;
+        xsSupplier = xs::iterator;
+        ysSupplier = ys::iterator;
         xsRef = new AtomicReference<>();
         ysRef = new AtomicReference<>();
-        afterXs = new LinkedList<>();
-        afterYs = new LinkedList<>();
+        iteratedXs = false;
     }
 
     @Override
     public boolean hasNext() {
-        queueNext(xsRef, xs, afterXs);
-
-        if (xsIterator().hasNext())
+        if (hasNext(xsRef, xsSupplier))
             return true;
 
-        queueNext(ysRef, ys, afterYs);
+        iteratedXs = true;
+        return hasNext(ysRef, ysSupplier);
+    }
 
-        return ysIterator().hasNext();
+    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
@@ -41,40 +42,6 @@ public A next() {
         if (!hasNext())
             throw new NoSuchElementException();
 
-        return xsIterator().hasNext() ? xsIterator().next() : ysIterator().next();
-    }
-
-    private Iterator<A> xsIterator() {
-        return xsRef.get();
+        return !iteratedXs ? xsRef.get().next() : ysRef.get().next();
     }
-
-    private Iterator<A> ysIterator() {
-        return ysRef.get();
-    }
-
-    private void queueNext(AtomicReference<Iterator<A>> iteratorRef, Iterable<A> iterable,
-                           Queue<Iterable<A>> queued) {
-        iteratorRef.updateAndGet(iterator -> {
-            if (iterator == null)
-                iterator = iterable.iterator();
-
-            while (iterator instanceof ConcatenatingIterator && iterator.hasNext()) {
-                ConcatenatingIterator<A> concatenatingXsIterator = (ConcatenatingIterator<A>) iterator;
-
-                if (concatenatingXsIterator.xsIterator().hasNext()) {
-                    queued.add(concatenatingXsIterator.ys);
-                    iterator = concatenatingXsIterator.xsIterator();
-                } else {
-                    iterator = concatenatingXsIterator.ysIterator();
-                }
-            }
-
-            while (!iterator.hasNext() && !queued.isEmpty()) {
-                iterator = queued.poll().iterator();
-            }
-
-            return iterator;
-        });
-    }
-
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/FlatteningIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/FlatteningIterator.java
new file mode 100644
index 000000000..7938ce880
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/FlatteningIterator.java
@@ -0,0 +1,29 @@
+package com.jnape.palatable.lambda.iterators;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public final class FlatteningIterator<A> extends ImmutableIterator<A> {
+    private final Iterator<? extends Iterable<? extends A>> xss;
+    private       Iterator<? extends A>                     xs;
+
+    public FlatteningIterator(Iterator<? extends Iterable<? extends A>> xss) {
+        this.xss = xss;
+    }
+
+    @Override
+    public boolean hasNext() {
+        while (xss.hasNext() && (xs == null || !xs.hasNext()))
+            xs = xss.next().iterator();
+
+        return xs != null && xs.hasNext();
+    }
+
+    @Override
+    public A next() {
+        if (!hasNext())
+            throw new NoSuchElementException();
+
+        return xs.next();
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/lenses/IterableLens.java b/src/main/java/com/jnape/palatable/lambda/lens/lenses/IterableLens.java
new file mode 100644
index 000000000..488822c9e
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/lens/lenses/IterableLens.java
@@ -0,0 +1,43 @@
+package com.jnape.palatable.lambda.lens.lenses;
+
+import com.jnape.palatable.lambda.functions.builtin.fn1.Head;
+import com.jnape.palatable.lambda.functions.builtin.fn1.Tail;
+import com.jnape.palatable.lambda.functions.builtin.fn2.Cons;
+import com.jnape.palatable.lambda.lens.Lens;
+
+import java.util.Optional;
+
+import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Cons.cons;
+import static com.jnape.palatable.lambda.lens.Lens.lens;
+import static com.jnape.palatable.lambda.lens.Lens.simpleLens;
+
+/**
+ * Lenses that operate on {@link Iterable}s.
+ */
+public final class IterableLens {
+
+    private IterableLens() {
+    }
+
+    /**
+     * A lens focusing on the head of a given {@link Iterable}.
+     *
+     * @param <A> the Iterable element type
+     * @return a lens focusing on the head element of an {@link Iterable}
+     */
+    public static <A> Lens<Iterable<A>, Iterable<A>, Optional<A>, A> head() {
+        return lens(Head::head, Cons.<A>cons().flip().compose(Tail.tail()).toBiFunction());
+    }
+
+    /**
+     * A lens focusing on the tail of an {@link Iterable}.
+     *
+     * @param <A> the Iterable element type
+     * @return a lens focusing on the tail of an {@link Iterable}
+     */
+    public static <A> Lens.Simple<Iterable<A>, Iterable<A>> tail() {
+        return simpleLens(Tail::tail, fn2(Head.<A>head().andThen(o -> o.map(cons()).orElse(id()))).toBiFunction());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Xor.java b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Xor.java
new file mode 100644
index 000000000..9341b05d3
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Xor.java
@@ -0,0 +1,38 @@
+package com.jnape.palatable.lambda.monoid.builtin;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.monoid.Monoid;
+
+/**
+ * Logical exclusive-or. Note that this implementation behaves as a cascade of binary exclusive-or operations, as is the
+ * only possible monoidal behavior when applied to an unknown number of inputs.
+ *
+ * @see Or
+ * @see And
+ */
+public final class Xor implements Monoid<Boolean> {
+
+    private static final Xor INSTANCE = new Xor();
+
+    @Override
+    public Boolean identity() {
+        return false;
+    }
+
+    @Override
+    public Boolean apply(Boolean x, Boolean y) {
+        return x ? !y : y;
+    }
+
+    public static Xor xor() {
+        return INSTANCE;
+    }
+
+    public static Fn1<Boolean, Boolean> xor(Boolean x) {
+        return xor().apply(x);
+    }
+
+    public static Boolean xor(Boolean x, Boolean y) {
+        return xor(x).apply(y);
+    }
+}
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 4e41513be..fd74b4502 100644
--- a/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java
+++ b/src/main/java/com/jnape/palatable/lambda/traversable/Traversable.java
@@ -2,6 +2,7 @@
 
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Functor;
+import com.jnape.palatable.lambda.functor.builtin.Identity;
 
 import java.util.function.Function;
 
@@ -46,5 +47,11 @@ <B, App extends Applicative> Applicative<? extends Traversable<B, T>, App> trave
             Function<? super Traversable<B, T>, ? extends Applicative<? extends Traversable<B, T>, App>> pure);
 
     @Override
-    <B> Traversable<B, T> fmap(Function<? super A, ? extends B> fn);
+    @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();
+    }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
index 878929a31..fdcc4b0cb 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
@@ -10,8 +10,6 @@
 
 import java.util.function.Function;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
 
 @RunWith(Traits.class)
@@ -32,16 +30,8 @@ public void profunctorProperties() {
     }
 
     @Test
-    public void thenIsJustAnAliasForFmap() {
-        Fn1<Integer, Integer> add2 = integer -> integer + 2;
-        Fn1<Integer, String> toString = Object::toString;
-
-        assertThat(add2.then(toString).apply(2), is(toString.apply(add2.apply(2))));
-    }
-
-    @Test
-    public void adapt() {
+    public void fn1() {
         Function<String, Integer> parseInt = Integer::parseInt;
-        assertEquals((Integer) 1, Fn1.adapt(parseInt).apply("1"));
+        assertEquals((Integer) 1, Fn1.fn1(parseInt).apply("1"));
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
index 6a845f11a..89cf70a03 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
@@ -8,6 +8,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 
 public class Fn2Test {
 
@@ -29,6 +30,12 @@ public void uncurries() {
         assertThat(CHECK_LENGTH.uncurry().apply(tuple("abc", 3)), is(true));
     }
 
+    @Test
+    @SuppressWarnings("ConstantConditions")
+    public void composePreservesTypeSpecificity() {
+        assertTrue(CHECK_LENGTH.compose(Object::toString) instanceof Fn2);
+    }
+
     @Test
     public void toBiFunction() {
         BiFunction<String, Integer, Boolean> biFunction = CHECK_LENGTH.toBiFunction();
@@ -36,8 +43,11 @@ public void toBiFunction() {
     }
 
     @Test
-    public void adapt() {
-        BiFunction<String, String, String> format = String::format;
-        assertEquals("foo bar", Fn2.adapt(format).apply("foo %s", "bar"));
+    public void fn2() {
+        BiFunction<String, String, String> biFunction = String::format;
+        assertEquals("foo bar", Fn2.fn2(biFunction).apply("foo %s", "bar"));
+
+        Fn1<String, Fn1<String, String>> curriedFn1 = (x) -> (y) -> String.format(x, y);
+        assertEquals("foo bar", Fn2.fn2(curriedFn1).apply("foo %s", "bar"));
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/DistinctTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/DistinctTest.java
new file mode 100644
index 000000000..4755af103
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/DistinctTest.java
@@ -0,0 +1,30 @@
+package com.jnape.palatable.lambda.functions.builtin.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.Distinct.distinct;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class DistinctTest {
+
+    @TestTraits({Laziness.class, InfiniteIterableSupport.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class})
+    public Distinct testSubject() {
+        return distinct();
+    }
+
+    @Test
+    public void producesIterableOfOnlySingleElementOccurrences() {
+        assertThat(distinct(asList(1, 2, 2, 3, 3, 3)), iterates(1, 2, 3));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/FlattenTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/FlattenTest.java
new file mode 100644
index 000000000..d428e7c17
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/FlattenTest.java
@@ -0,0 +1,43 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.builtin.fn2.Map;
+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.InfiniteIterableSupport;
+import testsupport.traits.Laziness;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Flatten.flatten;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singleton;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.isEmpty;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class FlattenTest {
+
+    @TestTraits({Laziness.class, InfiniteIterableSupport.class, EmptyIterableSupport.class, FiniteIteration.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return Flatten.<Integer>flatten().compose(Map.<Integer, Collection<Integer>>map(Collections::singletonList));
+    }
+
+    @Test
+    public void flattensIterableOfEmptyIterables() {
+        assertThat(flatten(asList(emptyList(), emptyList())), isEmpty());
+    }
+
+    @Test
+    public void flattensSparseIterableOfPopulatedIterables() {
+        assertThat(flatten(asList(emptyList(), asList(1, 2, 3), emptyList(), emptyList(), singleton(4), asList(5, 6), emptyList())),
+                   iterates(1, 2, 3, 4, 5, 6));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/SortTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/SortTest.java
new file mode 100644
index 000000000..61181d07c
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/SortTest.java
@@ -0,0 +1,27 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import org.junit.Test;
+import testsupport.traits.EmptyIterableSupport;
+import testsupport.traits.FiniteIteration;
+
+import java.util.List;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Sort.sort;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+public class SortTest {
+
+    @TestTraits({FiniteIteration.class, EmptyIterableSupport.class})
+    public Fn1<Iterable<Integer>, List<Integer>> testSubject() {
+        return sort();
+    }
+
+    @Test
+    public void sortsIterable() {
+        assertThat(sort(asList(2, 1, 3)), iterates(1, 2, 3));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReplicateTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReplicateTest.java
new file mode 100644
index 000000000..66848b16e
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReplicateTest.java
@@ -0,0 +1,21 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Replicate.replicate;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.isEmpty;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+public class ReplicateTest {
+
+    @Test
+    public void replicate0TimesProducesEmptyIterable() {
+        assertThat(replicate(0, 1), isEmpty());
+    }
+
+    @Test
+    public void replicateMoreThan0TimesProducesPopulatedIterable() {
+        assertThat(replicate(3, '1'), iterates('1', '1', '1'));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortByTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortByTest.java
new file mode 100644
index 000000000..bae0d1526
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SortByTest.java
@@ -0,0 +1,31 @@
+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 java.util.List;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.SortBy.sortBy;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class SortByTest {
+
+    @TestTraits({FiniteIteration.class, EmptyIterableSupport.class})
+    public Fn1<Iterable<Integer>, List<Integer>> testSubject() {
+        return sortBy(id());
+    }
+
+    @Test
+    public void sortsIterable() {
+        assertThat(sortBy(id(), asList(2, 1, 3)), iterates(1, 2, 3));
+    }
+}
\ 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
new file mode 100644
index 000000000..159878c0c
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/LiftA2Test.java
@@ -0,0 +1,22 @@
+package com.jnape.palatable.lambda.functions.builtin.fn3;
+
+import com.jnape.palatable.lambda.functor.builtin.Identity;
+import org.junit.Test;
+
+import java.util.function.BiFunction;
+
+import static com.jnape.palatable.lambda.adt.Either.right;
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.LiftA2.liftA2;
+import static org.junit.Assert.assertEquals;
+
+public class LiftA2Test {
+
+    @Test
+    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(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/iterators/ConcatenatingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/ConcatenatingIteratorTest.java
index f60bbcb3c..116e738fb 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ConcatenatingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/ConcatenatingIteratorTest.java
@@ -8,13 +8,14 @@
 
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.Optional;
 
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Drop.drop;
+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 java.util.Arrays.asList;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -26,9 +27,10 @@
 @RunWith(MockitoJUnitRunner.class)
 public class ConcatenatingIteratorTest {
 
-    @Mock private Iterator<Object>              xs;
-    @Mock private Iterator<Object>              ys;
-    private       ConcatenatingIterator<Object> concatenatingIterator;
+    @Mock private Iterator<Integer> xs;
+    @Mock private Iterator<Integer> ys;
+
+    private ConcatenatingIterator<Integer> concatenatingIterator;
 
     @Before
     public void setUp() throws Exception {
@@ -82,28 +84,16 @@ public void nextPullsFromXsFirstThenFromYs() {
     }
 
     @Test
-    public void concatenatingIteratorInXsPosition() {
-        ConcatenatingIterator<Integer> iterator =
-                new ConcatenatingIterator<>(() -> new ConcatenatingIterator<>(asList(1, 2), asList(3, 4)),
-                                            asList(5, 6));
-
-        assertThat(iterator.next(), is(1));
-        assertThat(iterator.next(), is(2));
-        assertThat(iterator.next(), is(3));
-        assertThat(iterator.next(), is(4));
-        assertThat(iterator.next(), is(5));
-        assertThat(iterator.next(), is(6));
-    }
-
-    @Test
-    public void stackSafetyInYsPosition() {
-        Integer stackBlowingNumber = 100000;
+    public void stackSafety() {
+        Integer stackBlowingNumber = 50000;
         Iterable<Iterable<Integer>> xss = map(Collections::singleton, take(stackBlowingNumber, iterate(x -> x + 1, 1)));
-        Iterable<Integer> ints = foldRight((xs, ys) -> () -> new ConcatenatingIterator<>(xs, ys),
-                                           (Iterable<Integer>) Collections.<Integer>emptySet(),
-                                           xss);
+        Iterable<Integer> deeplyNestedConcat = foldRight((xs, ys) -> () -> new ConcatenatingIterator<>(xs, ys),
+                                                         (Iterable<Integer>) Collections.<Integer>emptySet(),
+                                                         xss);
+
+        Iterable<Integer> ints = () -> new ConcatenatingIterator<>(deeplyNestedConcat, deeplyNestedConcat);
 
-        assertEquals(stackBlowingNumber,
-                     take(1, drop(stackBlowingNumber - 1, ints)).iterator().next());
+        assertEquals(Optional.of(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/iterators/FlatteningIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/FlatteningIteratorTest.java
new file mode 100644
index 000000000..e33cb656b
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/FlatteningIteratorTest.java
@@ -0,0 +1,34 @@
+package com.jnape.palatable.lambda.iterators;
+
+import org.junit.Test;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyIterator;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class FlatteningIteratorTest {
+
+    @Test
+    public void doesNotHaveNextForEmptyIterable() {
+        FlatteningIterator<Object> iterator = new FlatteningIterator<>(emptyIterator());
+        assertFalse(iterator.hasNext());
+    }
+
+    @Test
+    public void doesNotHaveNextForIterableOfEmptyIterables() {
+        FlatteningIterator<Object> iterator = new FlatteningIterator<>(singletonList(emptyList()).iterator());
+        assertFalse(iterator.hasNext());
+    }
+
+    @Test
+    public void iteratesNestedIterables() {
+        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());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/lenses/IterableLensTest.java b/src/test/java/com/jnape/palatable/lambda/lens/lenses/IterableLensTest.java
new file mode 100644
index 000000000..c6f0dd294
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/lens/lenses/IterableLensTest.java
@@ -0,0 +1,51 @@
+package com.jnape.palatable.lambda.lens.lenses;
+
+import com.jnape.palatable.lambda.lens.Lens;
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
+import static com.jnape.palatable.lambda.lens.functions.Over.over;
+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.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.isEmpty;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+public class IterableLensTest {
+
+    @Test
+    public void head() {
+        Lens<Iterable<Integer>, Iterable<Integer>, Optional<Integer>, Integer> head = IterableLens.head();
+
+        assertEquals(Optional.of(1), view(head, asList(1, 2, 3)));
+        assertEquals(Optional.empty(), view(head, emptyList()));
+
+        assertThat(set(head, 1, emptyList()), iterates(1));
+        assertThat(set(head, 1, asList(2, 2, 3)), iterates(1, 2, 3));
+
+        assertThat(over(head, x -> x.orElse(0) + 1, emptyList()), iterates(1));
+        assertThat(over(head, x -> x.orElse(0) + 1, asList(1, 2, 3)), iterates(2, 2, 3));
+    }
+
+    @Test
+    public void tail() {
+        Lens.Simple<Iterable<Integer>, Iterable<Integer>> tail = IterableLens.tail();
+
+        assertThat(view(tail, asList(1, 2, 3)), iterates(2, 3));
+        assertThat(view(tail, emptyList()), isEmpty());
+
+        assertThat(set(tail, asList(2, 3), singletonList(1)), iterates(1, 2, 3));
+        assertThat(set(tail, emptyList(), asList(1, 2, 3)), iterates(1));
+        assertThat(set(tail, asList(1, 2, 3), emptyList()), iterates(1, 2, 3));
+        assertThat(set(tail, emptyList(), emptyList()), isEmpty());
+
+        assertThat(over(tail, map(x -> x + 1), emptyList()), isEmpty());
+        assertThat(over(tail, map(x -> x + 1), asList(1, 2, 3)), iterates(1, 3, 4));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/monoid/builtin/XorTest.java b/src/test/java/com/jnape/palatable/lambda/monoid/builtin/XorTest.java
new file mode 100644
index 000000000..0f7aefeac
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/monoid/builtin/XorTest.java
@@ -0,0 +1,27 @@
+package com.jnape.palatable.lambda.monoid.builtin;
+
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.monoid.builtin.Xor.xor;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class XorTest {
+
+    @Test
+    public void identity() {
+        assertFalse(xor().identity());
+    }
+
+    @Test
+    public void monoid() {
+        assertFalse(xor(false, false));
+        assertTrue(xor(true, false));
+        assertTrue(xor(false, true));
+        assertFalse(xor(true, true));
+
+        assertTrue(xor().reduceLeft(asList(true, false, false, true, true)));
+        assertFalse(xor().reduceLeft(asList(true, false, true, false, false)));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/spike/TraversableIterableTest.java b/src/test/java/com/jnape/palatable/lambda/traversable/TraversableIterableTest.java
similarity index 89%
rename from src/test/java/spike/TraversableIterableTest.java
rename to src/test/java/com/jnape/palatable/lambda/traversable/TraversableIterableTest.java
index 1f179eb62..21a740b29 100644
--- a/src/test/java/spike/TraversableIterableTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/traversable/TraversableIterableTest.java
@@ -1,6 +1,5 @@
-package spike;
+package com.jnape.palatable.lambda.traversable;
 
-import com.jnape.palatable.lambda.traversable.TraversableIterable;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.framework.Subjects;
 import com.jnape.palatable.traitor.runners.Traits;
diff --git a/src/test/java/spike/TraversableOptionalTest.java b/src/test/java/com/jnape/palatable/lambda/traversable/TraversableOptionalTest.java
similarity index 89%
rename from src/test/java/spike/TraversableOptionalTest.java
rename to src/test/java/com/jnape/palatable/lambda/traversable/TraversableOptionalTest.java
index 85717ff43..13c330cb6 100644
--- a/src/test/java/spike/TraversableOptionalTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/traversable/TraversableOptionalTest.java
@@ -1,6 +1,5 @@
-package spike;
+package com.jnape.palatable.lambda.traversable;
 
-import com.jnape.palatable.lambda.traversable.TraversableOptional;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.framework.Subjects;
 import com.jnape.palatable.traitor.runners.Traits;