diff --git a/README.md b/README.md
index 076a31dad..2dd80178d 100644
--- a/README.md
+++ b/README.md
@@ -32,14 +32,14 @@ Add the following dependency to your:
  <dependency>
      <groupId>com.jnape.palatable</groupId>
      <artifactId>lambda</artifactId>
-     <version>1.1</version>
+     <version>1.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.1'
+  compile group: 'com.jnape.palatable', name: 'lambda', version: '1.2'
 ```
   
 
@@ -57,7 +57,7 @@ First, the obligatory `map`/`filter`/`reduce` example:
 
 Every function in lambda is [curried](https://www.wikiwand.com/en/Currying), so we could have also done this:
 ```Java
-  MonadicFunction<Iterable<Integer>, Integer> sumOfEvenIncrementsFn =
+  Fn1<Iterable<Integer>, Integer> sumOfEvenIncrementsFn =
             map((Integer x) -> x + 1)
             .then(filter(x -> x % 2 == 0))
             .then(reduceLeft((x, y) -> x + y));
@@ -95,20 +95,20 @@ What if we want the cross product of a domain and codomain:
 Let's compose two functions:
 
 ```Java
-  MonadicFunction<Integer, Integer> add = x -> x + 1;
-  MonadicFunction<Integer, Integer> subtract = x -> x -1;
+  Fn1<Integer, Integer> add = x -> x + 1;
+  Fn1<Integer, Integer> subtract = x -> x -1;
 
-  MonadicFunction<Integer, Integer> noOp = add.then(subtract);
+  Fn1<Integer, Integer> noOp = add.then(subtract);
   // same as
-  MonadicFunction<Integer, Integer> alsoNoOp = subtract.fmap(add);
+  Fn1<Integer, Integer> alsoNoOp = subtract.fmap(add);
 ```
 
 And partially apply some:
 
 ```Java
-  DyadicFunction<Integer, Integer, Integer> add = (x, y) -> x + y;
+  Fn2<Integer, Integer, Integer> add = (x, y) -> x + y;
 
-  MonadicFunction<Integer, Integer> add1 = add.apply(1);
+  Fn1<Integer, Integer> add1 = add.apply(1);
   add1.apply(2);
   //-> 3
 ```
@@ -152,7 +152,7 @@ To address this, tuples in lambda are specializations of `HList`s up to 5 elemen
 
 ```Java
   HNil nil = HList.nil();
-  Singleton<Integer> singleton = nil.cons(5);
+  SingletonHList<Integer> singleton = nil.cons(5);
   Tuple2<Integer, Integer> tuple2 = singleton.cons(4);
   Tuple3<Integer, Integer, Integer> tuple3 = tuple2.cons(3);
   Tuple4<Integer, Integer, Integer, Integer> tuple4 = tuple3.cons(2);
@@ -165,7 +165,7 @@ To address this, tuples in lambda are specializations of `HList`s up to 5 elemen
 Additionally, `HList` provides convenience static factory methods for directly constructing lists of up to 5 elements:
 
 ```Java
-  Singleton<Integer> singleton = HList.singleton(1);
+  SingletonHList<Integer> singleton = HList.singletonHList(1);
   Tuple2<Integer, Integer> tuple2 = HList.tuple(1, 2);
   Tuple3<Integer, Integer, Integer> tuple3 = HList.tuple(1, 2, 3);
   Tuple4<Integer, Integer, Integer, Integer> tuple4 = HList.tuple(1, 2, 3, 4);
@@ -187,6 +187,21 @@ Finally, all `Tuple*` classes are instances of both `Functor` and `Bifunctor`:
   System.out.println(mappedTuple3._3()); // prints 2
 ```
 
+### Heterogeneous Maps
+
+HMaps are type-safe heterogeneous maps, meaning they can store mappings to different value types in the same map; however, whereas HLists encode value types in their type signatures, HMaps rely on the keys to encode the value type that they point to. 
+
+```Java
+  TypeSafeKey<String> stringKey = TypeSafeKey.typeSafeKey();
+  TypeSafeKey<Integer> intKey = TypeSafeKey.typeSafeKey();
+  HMap hmap = HMap.hMap(stringKey, "string value",
+                        intKey, 1);
+
+  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
+```    
+
 ### Either
 
 Binary tagged unions are represented as `Either<L, R>`s, which resolve to one of two possible values: a `Left` value wrapping an `L`, or a `Right` value wrapping an `R` (typically an exceptional value or a successful value, respectively).
diff --git a/pom.xml b/pom.xml
index 30e571f91..215859eae 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,7 +9,7 @@
     </parent>
 
     <artifactId>lambda</artifactId>
-    <version>1.2</version>
+    <version>1.3</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 b286f7d54..371e5d355 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/Either.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.adt;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.specialized.checked.CheckedSupplier;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
@@ -11,7 +11,7 @@
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
  * The binary tagged union. General semantics tend to connote "success" values via the right value and "failure" values
@@ -26,52 +26,136 @@ public abstract class Either<L, R> implements Functor<R>, Bifunctor<L, R> {
     private Either() {
     }
 
+    /**
+     * Return the value wrapped by this <code>Either</code> if it's a right value; otherwise, return defaultValue.
+     *
+     * @param defaultValue the value to return if this is a left
+     * @return the value wrapped by this Either if right; otherwise, defaultValue
+     */
     public final R or(R defaultValue) {
         return recover(l -> defaultValue);
     }
 
-    public final R recover(MonadicFunction<? super L, ? extends R> recoveryFn) {
+    /**
+     * "Recover" from a left value by applying a recoveryFn to the wrapped value and returning it in the case of a left
+     * value; otherwise, return the wrapped right value.
+     *
+     * @param recoveryFn a function from L to R
+     * @return either the wrapped value (if right) or the result of the left value applied to recoveryFn
+     */
+    public final R recover(Fn1<? super L, ? extends R> recoveryFn) {
         return match(recoveryFn, id());
     }
 
-    public final L forfeit(MonadicFunction<? super R, ? extends L> forfeitFn) {
+    /**
+     * Inverse of recover. If this is a right value, apply the wrapped value to forfeitFn and return it; otherwise,
+     * return the wrapped left value;
+     *
+     * @param forfeitFn a function from R to L
+     * @return either the wrapped value (if left) or the result of the right value applied to forfeitFn
+     */
+    public final L forfeit(Fn1<? super R, ? extends L> forfeitFn) {
         return match(id(), forfeitFn);
     }
 
-    public final <E extends RuntimeException> R orThrow(
-            MonadicFunction<? super L, ? extends E> throwableFn) throws E {
+    /**
+     * Return the wrapped value if this is a right; otherwise, map the wrapped left value to an <code>E</code> and throw
+     * it.
+     *
+     * @param throwableFn a function from L to E
+     * @param <E>         the left parameter type (the throwable exception type)
+     * @return the wrapped value if this is a right
+     * @throws E the result of applying the wrapped left value to throwableFn, if this is a left
+     */
+    public final <E extends RuntimeException> R orThrow(Fn1<? super L, ? extends E> throwableFn) throws E {
         return match(l -> {
             throw throwableFn.apply(l);
         }, id());
     }
 
-    public final Either<L, R> filter(MonadicFunction<? super R, Boolean> pred,
-                                     Supplier<L> leftSupplier) {
+    /**
+     * If this is a right value, apply pred to it. If the result is true, return the same value; otherwise, return the
+     * result of leftSupplier wrapped as a left value.
+     * <p>
+     * If this is a left value, return it.
+     *
+     * @param pred         the predicate to apply to a right value
+     * @param leftSupplier the supplier of a left value if pred fails
+     * @return this if a left value or a right value that pred matches; otherwise, the result of leftSupplier wrapped in
+     * a left
+     */
+    public final Either<L, R> filter(Fn1<? super R, Boolean> pred, Supplier<L> leftSupplier) {
         return flatMap(r -> pred.apply(r) ? right(r) : left(leftSupplier.get()));
     }
 
-    public final <R2> Either<L, R2> flatMap(MonadicFunction<? super R, ? extends Either<L, R2>> rightFn) {
+    /**
+     * If a right value, unwrap it and apply it to <code>rightFn</code>, returning the resulting
+     * <code>Either&lt;L ,R&gt;</code>. Otherwise, return the left value.
+     * <p>
+     * Note that because this monadic form of <code>flatMap</code> only supports mapping over a theoretical right value,
+     * the resulting <code>Either</code> must be invariant on the same left value to flatten properly.
+     *
+     * @param rightFn the function to apply to a right value
+     * @param <R2>    the new right parameter type
+     * @return the Either resulting from applying rightFn to this right value, or this left value if left
+     */
+    public final <R2> Either<L, R2> flatMap(Fn1<? super R, ? extends Either<L, R2>> rightFn) {
         return flatMap(Either::left, rightFn);
     }
 
-    public final <L2, R2> Either<L2, R2> flatMap(MonadicFunction<? super L, ? extends Either<L2, R2>> leftFn,
-                                                 MonadicFunction<? super R, ? extends Either<L2, R2>> rightFn) {
+    /**
+     * If a right value, apply <code>rightFn</code> to the unwrapped right value and return the resulting
+     * <code>Either</code>; otherwise, apply the unwrapped left value to leftFn and return the resulting
+     * <code>Either</code>.
+     *
+     * @param leftFn  the function to apply if a left value
+     * @param rightFn the function to apply if a right value
+     * @param <L2>    the new left parameter type
+     * @param <R2>    the new right parameter type
+     * @return the result of either rightFn or leftFn, depending on whether this is a right or a left
+     */
+    public final <L2, R2> Either<L2, R2> flatMap(Fn1<? super L, ? extends Either<L2, R2>> leftFn,
+                                                 Fn1<? super R, ? extends Either<L2, R2>> rightFn) {
         return match(leftFn, rightFn);
     }
 
-    public final Either<L, R> merge(DyadicFunction<? super L, ? super L, ? extends L> leftFn,
-                                    DyadicFunction<? super R, ? super R, ? extends R> rightFn,
+    /**
+     * Given two binary operators over L and R, merge two <code>Either&lt;L, R&gt;</code>s into a single
+     * <code>Either&lt;L, R&gt;</code>. Note that <code>merge</code> biases towards left values; that is, if any left
+     * value exists, the result will be a left value, such that only unanimous right values result in an ultimate right
+     * value.
+     *
+     * @param leftFn  the binary operator for L
+     * @param rightFn the binary operator for R
+     * @param other   the other Either
+     * @return the merged Either
+     */
+    public final Either<L, R> merge(Fn2<? super L, ? super L, ? extends L> leftFn,
+                                    Fn2<? super R, ? super R, ? extends R> rightFn,
                                     Either<L, R> other) {
         return this.match(
                 l1 -> other.match(l2 -> left(leftFn.apply(l1, l2)), r -> left(l1)),
                 r1 -> other.match(Either::left, r2 -> right(rightFn.apply(r1, r2))));
     }
 
+    /**
+     * Perform side-effects against a wrapped right value, returning back the <code>Either</code> unaltered.
+     *
+     * @param rightConsumer the effecting consumer
+     * @return the Either, unaltered
+     */
     public Either<L, R> peek(Consumer<R> rightConsumer) {
         return peek(l -> {
         }, rightConsumer);
     }
 
+    /**
+     * Perform side-effects against a wrapped right or left value, returning back the <code>Either</code> unaltered.
+     *
+     * @param leftConsumer  the effecting consumer for left values
+     * @param rightConsumer the effecting consumer for right values
+     * @return the Either, unaltered
+     */
     public Either<L, R> peek(Consumer<L> leftConsumer, Consumer<R> rightConsumer) {
         return flatMap(l -> {
             leftConsumer.accept(l);
@@ -82,40 +166,70 @@ public Either<L, R> peek(Consumer<L> leftConsumer, Consumer<R> rightConsumer) {
         });
     }
 
-    public abstract <V> V match(MonadicFunction<? super L, ? extends V> leftFn,
-                                MonadicFunction<? super R, ? extends V> rightFn);
+    /**
+     * Given two mapping functions (one from an <code>L</code> to a <code>V</code>, one from an <code>R</code> to a
+     * <code>V</code>), unwrap the value stored in this <code>Either</code>, apply the appropriate mapping function,
+     * and return the result.
+     *
+     * @param leftFn  the left value mapping function
+     * @param rightFn the right value mapping function
+     * @param <V>     the result type
+     * @return the result of applying the appropriate mapping function to the wrapped value
+     */
+    public abstract <V> V match(Fn1<? super L, ? extends V> leftFn, Fn1<? super R, ? extends V> rightFn);
 
     @Override
-    public final <R2> Either<L, R2> fmap(MonadicFunction<? super R, ? extends R2> fn) {
+    public final <R2> Either<L, R2> fmap(Fn1<? super R, ? extends R2> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public final <L2> Either<L2, R> biMapL(MonadicFunction<? super L, ? extends L2> fn) {
+    public final <L2> Either<L2, R> biMapL(Fn1<? super L, ? extends L2> fn) {
         return (Either<L2, R>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public final <R2> Either<L, R2> biMapR(MonadicFunction<? super R, ? extends R2> fn) {
+    public final <R2> Either<L, R2> biMapR(Fn1<? super R, ? extends R2> fn) {
         return (Either<L, R2>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public final <L2, R2> Either<L2, R2> biMap(MonadicFunction<? super L, ? extends L2> leftFn,
-                                               MonadicFunction<? super R, ? extends R2> rightFn) {
+    public final <L2, R2> Either<L2, R2> biMap(Fn1<? super L, ? extends L2> leftFn,
+                                               Fn1<? super R, ? extends R2> rightFn) {
         return match(l -> left(leftFn.apply(l)), r -> right(rightFn.apply(r)));
     }
 
+    /**
+     * Convert an {@link Optional}&lt;R&gt; into an <code>Either&lt;L, R&gt;</code>, supplying the left value from
+     * <code>leftFn</code> in the case of {@link Optional#empty()}.
+     *
+     * @param optional the optional
+     * @param leftFn   the supplier to use for left values
+     * @param <L>      the left parameter type
+     * @param <R>      the right parameter type
+     * @return a right value of the contained optional value, or a left value of leftFn's result
+     */
     public static <L, R> Either<L, R> fromOptional(Optional<R> optional, Supplier<L> leftFn) {
         return optional.<Either<L, R>>map(Either::right)
                 .orElse(left(leftFn.get()));
     }
 
+    /**
+     * Attempt to execute the {@link CheckedSupplier}, returning its result in a right value. If the supplier throws an
+     * exception, apply leftFn to it, wrap it in a left value and return it.
+     *
+     * @param supplier the supplier of the right value
+     * @param leftFn   a function mapping E to L
+     * @param <E>      the most contravariant exception that the supplier might throw
+     * @param <L>      the left parameter type
+     * @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,
-                                                                  MonadicFunction<? super E, ? extends L> leftFn) {
+                                                                  Fn1<? super E, ? extends L> leftFn) {
         try {
             return right(supplier.get());
         } catch (Exception e) {
@@ -123,14 +237,39 @@ public static <E extends Exception, L, R> Either<L, R> trying(CheckedSupplier<E,
         }
     }
 
+    /**
+     * Attempt to execute the {@link CheckedSupplier}, returning its result in a right value. If the supplier throws an
+     * exception, wrap it in a left value and return it.
+     *
+     * @param supplier the supplier of the right value
+     * @param <E>      the left parameter type (the most contravariant exception that supplier might throw)
+     * @param <R>      the right parameter type
+     * @return the supplier result as a right value, or a left value of the thrown exception
+     */
     public static <E extends Exception, R> Either<E, R> trying(CheckedSupplier<E, R> supplier) {
         return trying(supplier, id());
     }
 
+    /**
+     * Static factory method for creating a left value.
+     *
+     * @param l   the wrapped value
+     * @param <L> the left parameter type
+     * @param <R> the right parameter type
+     * @return a left value of l
+     */
     public static <L, R> Either<L, R> left(L l) {
         return new Left<>(l);
     }
 
+    /**
+     * Static factory method for creating a right value.
+     *
+     * @param r   the wrapped value
+     * @param <L> the left parameter type
+     * @param <R> the right parameter type
+     * @return a right value of r
+     */
     public static <L, R> Either<L, R> right(R r) {
         return new Right<>(r);
     }
@@ -143,8 +282,7 @@ private Left(L l) {
         }
 
         @Override
-        public <V> V match(MonadicFunction<? super L, ? extends V> leftFn,
-                           MonadicFunction<? super R, ? extends V> rightFn) {
+        public <V> V match(Fn1<? super L, ? extends V> leftFn, Fn1<? super R, ? extends V> rightFn) {
             return leftFn.apply(l);
         }
 
@@ -174,8 +312,7 @@ private Right(R r) {
         }
 
         @Override
-        public <V> V match(MonadicFunction<? super L, ? extends V> leftFn,
-                           MonadicFunction<? super R, ? extends V> rightFn) {
+        public <V> V match(Fn1<? super L, ? extends V> leftFn, Fn1<? super R, ? extends V> rightFn) {
             return rightFn.apply(r);
         }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java
index feee8be92..aaebee9c7 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java
@@ -3,12 +3,13 @@
 import java.util.Objects;
 
 /**
- * A heterogeneous list supporting arbitrary depth type-safety via a linearly recursive type signature. Note that due to
- * its rapidly expanding type signature, specializations exist up to certain depths to minimize typing overhead.
+ * An immutable heterogeneous list supporting arbitrary depth type-safety via a linearly recursive type signature. Note
+ * that due to its rapidly expanding type signature, specializations exist up to certain depths to minimize typing
+ * overhead.
  *
  * @param <Head> The head element type
  * @param <Tail> The encoded recursive tail HList type
- * @see Singleton
+ * @see SingletonHList
  * @see Tuple2
  * @see Tuple3
  * @see Tuple4
@@ -19,32 +20,116 @@ public abstract class HList<Head, Tail extends HList<?, ?>> {
     private HList() {
     }
 
+    /**
+     * Cons an element onto the front of this HList.
+     *
+     * @param newHead   the new head element
+     * @param <NewHead> the new head type
+     * @return the updated HList
+     */
     public abstract <NewHead> HCons<NewHead, ? extends HList<Head, Tail>> cons(NewHead newHead);
 
+    /**
+     * Static factory method for creating empty HLists.
+     *
+     * @return an empty HList
+     */
     public static HNil nil() {
         return HNil.INSTANCE;
     }
 
+    /**
+     * Static factory method for creating an HList from the given head and tail.
+     *
+     * @param head   the head element
+     * @param tail   the tail HList
+     * @param <Head> the head type
+     * @param <Tail> the tail type
+     * @return the newly created HList
+     */
     public static <Head, Tail extends HList<?, ?>> HCons<Head, Tail> cons(Head head, Tail tail) {
         return new HCons<>(head, tail);
     }
 
-    public static <Head> Singleton<Head> singleton(Head head) {
-        return new Singleton<>(head);
+    /**
+     * Static factory method for creating a singleton HList.
+     *
+     * @param head   the head element
+     * @param <Head> the head element type
+     * @return the singleton HList
+     */
+    public static <Head> SingletonHList<Head> singletonHList(Head head) {
+        return new SingletonHList<>(head);
     }
 
+    /**
+     * Static factory method for creating a 2-element HList.
+     *
+     * @param _1   the head element
+     * @param _2   the second element
+     * @param <_1> the head element type
+     * @param <_2> the second element type
+     * @return the 2-element HList
+     * @see Tuple2
+     */
+    @SuppressWarnings("JavaDoc")
     public static <_1, _2> Tuple2<_1, _2> tuple(_1 _1, _2 _2) {
-        return singleton(_2).cons(_1);
+        return singletonHList(_2).cons(_1);
     }
 
+    /**
+     * Static factory method for creating a 3-element HList.
+     *
+     * @param _1   the head element
+     * @param _2   the second element
+     * @param _3   the third element
+     * @param <_1> the head element type
+     * @param <_2> the second element type
+     * @param <_3> the third element type
+     * @return the 3-element HList
+     * @see Tuple3
+     */
+    @SuppressWarnings("JavaDoc")
     public static <_1, _2, _3> Tuple3<_1, _2, _3> tuple(_1 _1, _2 _2, _3 _3) {
         return tuple(_2, _3).cons(_1);
     }
 
+    /**
+     * Static factory method for creating a 4-element HList.
+     *
+     * @param _1   the head element
+     * @param _2   the second element
+     * @param _3   the third element
+     * @param _4   the fourth element
+     * @param <_1> the head element type
+     * @param <_2> the second element type
+     * @param <_3> the third element type
+     * @param <_4> the fourth element type
+     * @return the 4-element HList
+     * @see Tuple4
+     */
+    @SuppressWarnings("JavaDoc")
     public static <_1, _2, _3, _4> Tuple4<_1, _2, _3, _4> tuple(_1 _1, _2 _2, _3 _3, _4 _4) {
         return tuple(_2, _3, _4).cons(_1);
     }
 
+    /**
+     * Static factory method for creating a 5-element HList.
+     *
+     * @param _1   the head element
+     * @param _2   the second element
+     * @param _3   the third element
+     * @param _4   the fourth element
+     * @param _5   the fifth element
+     * @param <_1> the head element type
+     * @param <_2> the second element type
+     * @param <_3> the third element type
+     * @param <_4> the fourth element type
+     * @param <_5> the fifth element type
+     * @return the 5-element HList
+     * @see Tuple5
+     */
+    @SuppressWarnings("JavaDoc")
     public static <_1, _2, _3, _4, _5> Tuple5<_1, _2, _3, _4, _5> tuple(_1 _1, _2 _2, _3 _3, _4 _4, _5 _5) {
         return tuple(_2, _3, _4, _5).cons(_1);
     }
@@ -75,9 +160,8 @@ public Tail tail() {
         public final boolean equals(Object other) {
             if (other instanceof HCons) {
                 HCons that = (HCons) other;
-                boolean sameHead = this.head.equals(that.head);
-                boolean sameTail = this.tail.equals(that.tail);
-                return sameHead && sameTail;
+                return this.head.equals(that.head)
+                        && this.tail.equals(that.tail);
             }
             return false;
         }
@@ -99,9 +183,12 @@ public final String toString() {
     public static final class HNil extends HList<Void, HNil> {
         private static final HNil INSTANCE = new HNil();
 
+        private HNil() {
+        }
+
         @Override
-        public <Head> Singleton<Head> cons(Head head) {
-            return new Singleton<>(head);
+        public <Head> SingletonHList<Head> cons(Head head) {
+            return new SingletonHList<>(head);
         }
 
         @Override
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
similarity index 55%
rename from src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java
rename to src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
index fc6e66ee5..f651328a8 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
@@ -2,11 +2,13 @@
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
 import com.jnape.palatable.lambda.adt.hlist.HList.HNil;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Functor;
 
+import java.util.RandomAccess;
+
 /**
- * A singleton HList.
+ * A singleton HList. Supports random access.
  *
  * @param <_1> The single slot element type
  * @see HList
@@ -15,9 +17,9 @@
  * @see Tuple4
  * @see Tuple5
  */
-public final class Singleton<_1> extends HCons<_1, HNil> implements Functor<_1> {
+public class SingletonHList<_1> extends HCons<_1, HNil> implements Functor<_1>, RandomAccess {
 
-    Singleton(_1 _1) {
+    SingletonHList(_1 _1) {
         super(_1, nil());
     }
 
@@ -27,7 +29,7 @@ public <_0> Tuple2<_0, _1> cons(_0 _0) {
     }
 
     @Override
-    public <_1Prime> Singleton<_1Prime> fmap(MonadicFunction<? super _1, ? extends _1Prime> fn) {
-        return new Singleton<>(fn.apply(head()));
+    public <_1Prime> SingletonHList<_1Prime> fmap(Fn1<? super _1, ? extends _1Prime> fn) {
+        return new SingletonHList<>(fn.apply(head()));
     }
 }
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 35001f291..222fb1f23 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
@@ -1,27 +1,32 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
 
 import java.util.Map;
 
 /**
- * A 2-element tuple product type, implemented as a specialized HList.
+ * A 2-element tuple product type, implemented as a specialized HList. Supports random access.
  *
  * @param <_1> The first slot element type
  * @param <_2> The second slot element type
  * @see HList
- * @see Singleton
+ * @see SingletonHList
  * @see Tuple3
  * @see Tuple4
  * @see Tuple5
  */
-public final class Tuple2<_1, _2> extends HCons<_1, Singleton<_2>> implements Map.Entry<_1, _2>, Functor<_2>, Bifunctor<_1, _2> {
+public class Tuple2<_1, _2> extends HCons<_1, SingletonHList<_2>> implements Map.Entry<_1, _2>, Functor<_2>, Bifunctor<_1, _2> {
 
-    Tuple2(_1 _1, Singleton<_2> tail) {
+    private final _1 _1;
+    private final _2 _2;
+
+    Tuple2(_1 _1, SingletonHList<_2> tail) {
         super(_1, tail);
+        this._1 = _1;
+        _2 = tail.head();
     }
 
     @Override
@@ -29,12 +34,22 @@ public <_0> Tuple3<_0, _1, _2> cons(_0 _0) {
         return new Tuple3<>(_0, this);
     }
 
+    /**
+     * Retrieve the first (head) element in constant time.
+     *
+     * @return the head element
+     */
     public _1 _1() {
-        return head();
+        return _1;
     }
 
+    /**
+     * Retrieve the second element in constant time.
+     *
+     * @return the second element
+     */
     public _2 _2() {
-        return tail().head();
+        return _2;
     }
 
     @Override
@@ -53,29 +68,37 @@ public _2 setValue(_2 value) {
     }
 
     @Override
-    public <_2Prime> Tuple2<_1, _2Prime> fmap(MonadicFunction<? super _2, ? extends _2Prime> fn) {
+    public <_2Prime> Tuple2<_1, _2Prime> fmap(Fn1<? super _2, ? extends _2Prime> fn) {
         return tuple(_1(), fn.apply(_2()));
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_1Prime> Tuple2<_1Prime, _2> biMapL(MonadicFunction<? super _1, ? extends _1Prime> fn) {
+    public <_1Prime> Tuple2<_1Prime, _2> biMapL(Fn1<? super _1, ? extends _1Prime> fn) {
         return (Tuple2<_1Prime, _2>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_2Prime> Tuple2<_1, _2Prime> biMapR(MonadicFunction<? super _2, ? extends _2Prime> fn) {
+    public <_2Prime> Tuple2<_1, _2Prime> biMapR(Fn1<? super _2, ? extends _2Prime> fn) {
         return (Tuple2<_1, _2Prime>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(MonadicFunction<? super _1, ? extends _1Prime> lFn,
-                                                             MonadicFunction<? super _2, ? extends _2Prime> rFn) {
+    public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(Fn1<? super _1, ? extends _1Prime> lFn,
+                                                             Fn1<? super _2, ? extends _2Prime> rFn) {
         return new Tuple2<>(lFn.apply(_1()), tail().fmap(rFn));
     }
 
+    /**
+     * Static factory method for creating <code>Tuple2</code>s from {@link java.util.Map.Entry}s.
+     *
+     * @param entry the map entry
+     * @param <K>   the key parameter type, and first (head) element type
+     * @param <V>   the value parameter type, and second element type
+     * @return the newly created Tuple2
+     */
     public static <K, V> Tuple2<K, V> fromEntry(Map.Entry<K, V> entry) {
-        return new Tuple2<>(entry.getKey(), singleton(entry.getValue()));
+        return new Tuple2<>(entry.getKey(), singletonHList(entry.getValue()));
     }
 }
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 45c711b1d..acc840e06 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
@@ -1,25 +1,32 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
 
 /**
- * A 3-element tuple product type, implemented as a specialized HList.
+ * A 3-element tuple product type, implemented as a specialized HList. Supports random access.
  *
  * @param <_1> The first slot element type
  * @param <_2> The second slot element type
  * @param <_3> The third slot element type
  * @see HList
- * @see Singleton
+ * @see SingletonHList
  * @see Tuple2
  * @see Tuple4
  * @see Tuple5
  */
-public final class Tuple3<_1, _2, _3> extends HCons<_1, Tuple2<_2, _3>> implements Functor<_3>, Bifunctor<_2, _3> {
+public class Tuple3<_1, _2, _3> extends HCons<_1, Tuple2<_2, _3>> implements Functor<_3>, Bifunctor<_2, _3> {
+    private final _1 _1;
+    private final _2 _2;
+    private final _3 _3;
+
     Tuple3(_1 _1, Tuple2<_2, _3> tail) {
         super(_1, tail);
+        this._1 = _1;
+        _2 = tail._1();
+        _3 = tail._2();
     }
 
     @Override
@@ -27,38 +34,53 @@ public <_0> Tuple4<_0, _1, _2, _3> cons(_0 _0) {
         return new Tuple4<>(_0, this);
     }
 
+    /**
+     * Retrieve the first (head) element in constant time.
+     *
+     * @return the head element
+     */
     public _1 _1() {
-        return head();
+        return _1;
     }
 
+    /**
+     * Retrieve the second element in constant time.
+     *
+     * @return the second element
+     */
     public _2 _2() {
-        return tail()._1();
+        return _2;
     }
 
+    /**
+     * Retrieve the third element in constant time.
+     *
+     * @return the third element
+     */
     public _3 _3() {
-        return tail()._2();
+        return _3;
     }
 
     @Override
-    public <_3Prime> Tuple3<_1, _2, _3Prime> fmap(MonadicFunction<? super _3, ? extends _3Prime> fn) {
+    public <_3Prime> Tuple3<_1, _2, _3Prime> fmap(Fn1<? super _3, ? extends _3Prime> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_2Prime> Tuple3<_1, _2Prime, _3> biMapL(MonadicFunction<? super _2, ? extends _2Prime> fn) {
+    public <_2Prime> Tuple3<_1, _2Prime, _3> biMapL(Fn1<? super _2, ? extends _2Prime> fn) {
         return (Tuple3<_1, _2Prime, _3>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_3Prime> Tuple3<_1, _2, _3Prime> biMapR(MonadicFunction<? super _3, ? extends _3Prime> fn) {
+    public <_3Prime> Tuple3<_1, _2, _3Prime> biMapR(Fn1<? super _3, ? extends _3Prime> fn) {
         return (Tuple3<_1, _2, _3Prime>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public <_2Prime, _3Prime> Tuple3<_1, _2Prime, _3Prime> biMap(MonadicFunction<? super _2, ? extends _2Prime> lFn,
-                                                                 MonadicFunction<? super _3, ? extends _3Prime> rFn) {
+    public <_2Prime, _3Prime> Tuple3<_1, _2Prime, _3Prime> biMap(Fn1<? super _2, ? extends _2Prime> lFn,
+                                                                 Fn1<? super _3, ? extends _3Prime> rFn) {
         return new Tuple3<>(_1(), tail().biMap(lFn, rFn));
     }
 }
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 1e655389f..38208b713 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
@@ -1,26 +1,35 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
 
 /**
- * A 4-element tuple product type, implemented as a specialized HList.
+ * A 4-element tuple product type, implemented as a specialized HList. Supports random access.
  *
  * @param <_1> The first slot element type
  * @param <_2> The second slot element type
  * @param <_3> The third slot element type
  * @param <_4> The fourth slot element type
  * @see HList
- * @see Singleton
+ * @see SingletonHList
  * @see Tuple2
  * @see Tuple3
  * @see Tuple5
  */
-public final class Tuple4<_1, _2, _3, _4> extends HCons<_1, Tuple3<_2, _3, _4>> implements Functor<_4>, Bifunctor<_3, _4> {
+public class Tuple4<_1, _2, _3, _4> extends HCons<_1, Tuple3<_2, _3, _4>> implements Functor<_4>, Bifunctor<_3, _4> {
+    private final _1 _1;
+    private final _2 _2;
+    private final _3 _3;
+    private final _4 _4;
+
     Tuple4(_1 _1, Tuple3<_2, _3, _4> tail) {
         super(_1, tail);
+        this._1 = _1;
+        _2 = tail._1();
+        _3 = tail._2();
+        _4 = tail._3();
     }
 
     @Override
@@ -28,42 +37,62 @@ public <_0> Tuple5<_0, _1, _2, _3, _4> cons(_0 _0) {
         return new Tuple5<>(_0, this);
     }
 
+    /**
+     * Retrieve the first (head) element in constant time.
+     *
+     * @return the head element
+     */
     public _1 _1() {
-        return head();
+        return _1;
     }
 
+    /**
+     * Retrieve the second element in constant time.
+     *
+     * @return the second element
+     */
     public _2 _2() {
-        return tail()._1();
+        return _2;
     }
 
+    /**
+     * Retrieve the third element in constant time.
+     *
+     * @return the third element
+     */
     public _3 _3() {
-        return tail()._2();
+        return _3;
     }
 
+    /**
+     * Retrieve the fourth element in constant time.
+     *
+     * @return the fourth element
+     */
     public _4 _4() {
-        return tail()._3();
+        return _4;
     }
 
     @Override
-    public <_4Prime> Tuple4<_1, _2, _3, _4Prime> fmap(MonadicFunction<? super _4, ? extends _4Prime> fn) {
+    public <_4Prime> Tuple4<_1, _2, _3, _4Prime> fmap(Fn1<? super _4, ? extends _4Prime> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_3Prime> Tuple4<_1, _2, _3Prime, _4> biMapL(MonadicFunction<? super _3, ? extends _3Prime> fn) {
+    public <_3Prime> Tuple4<_1, _2, _3Prime, _4> biMapL(Fn1<? super _3, ? extends _3Prime> fn) {
         return (Tuple4<_1, _2, _3Prime, _4>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_4Prime> Tuple4<_1, _2, _3, _4Prime> biMapR(MonadicFunction<? super _4, ? extends _4Prime> fn) {
+    public <_4Prime> Tuple4<_1, _2, _3, _4Prime> biMapR(Fn1<? super _4, ? extends _4Prime> fn) {
         return (Tuple4<_1, _2, _3, _4Prime>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public <_3Prime, _4Prime> Tuple4<_1, _2, _3Prime, _4Prime> biMap(MonadicFunction<? super _3, ? extends _3Prime> lFn,
-                                                                     MonadicFunction<? super _4, ? extends _4Prime> rFn) {
+    public <_3Prime, _4Prime> Tuple4<_1, _2, _3Prime, _4Prime> biMap(Fn1<? super _3, ? extends _3Prime> lFn,
+                                                                     Fn1<? super _4, ? extends _4Prime> rFn) {
         return new Tuple4<>(_1(), tail().biMap(lFn, rFn));
     }
 }
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 ead0b387f..49cf2c29a 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
@@ -1,12 +1,12 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
 
 /**
- * A 5-element tuple product type, implemented as a specialized HList.
+ * A 5-element tuple product type, implemented as a specialized HList. Supports random access.
  *
  * @param <_1> The first slot element type
  * @param <_2> The second slot element type
@@ -14,14 +14,25 @@
  * @param <_4> The fourth slot element type
  * @param <_5> The fifth slot element type
  * @see HList
- * @see Singleton
+ * @see SingletonHList
  * @see Tuple2
  * @see Tuple3
  * @see Tuple4
  */
-public final class Tuple5<_1, _2, _3, _4, _5> extends HCons<_1, Tuple4<_2, _3, _4, _5>> implements Functor<_5>, Bifunctor<_4, _5> {
-    Tuple5(_1 a, Tuple4<_2, _3, _4, _5> tail) {
-        super(a, tail);
+public class Tuple5<_1, _2, _3, _4, _5> extends HCons<_1, Tuple4<_2, _3, _4, _5>> implements Functor<_5>, Bifunctor<_4, _5> {
+    private final _1 _1;
+    private final _2 _2;
+    private final _3 _3;
+    private final _4 _4;
+    private final _5 _5;
+
+    Tuple5(_1 _1, Tuple4<_2, _3, _4, _5> tail) {
+        super(_1, tail);
+        this._1 = _1;
+        _2 = tail._1();
+        _3 = tail._2();
+        _4 = tail._3();
+        _5 = tail._4();
     }
 
     @Override
@@ -29,47 +40,71 @@ public <_0> HCons<_0, Tuple5<_1, _2, _3, _4, _5>> cons(_0 _0) {
         return new HCons<>(_0, this);
     }
 
+    /**
+     * Retrieve the first (head) element in constant time.
+     *
+     * @return the head element
+     */
     public _1 _1() {
-        return head();
+        return _1;
     }
 
+    /**
+     * Retrieve the second element in constant time.
+     *
+     * @return the second element
+     */
     public _2 _2() {
-        return tail()._1();
+        return _2;
     }
 
+    /**
+     * Retrieve the third element in constant time.
+     *
+     * @return the third element
+     */
     public _3 _3() {
-        return tail()._2();
+        return _3;
     }
 
+    /**
+     * Retrieve the fourth element in constant time.
+     *
+     * @return the fourth element
+     */
     public _4 _4() {
-        return tail()._3();
+        return _4;
     }
 
+    /**
+     * Retrieve the fifth element in constant time.
+     *
+     * @return the fifth element
+     */
     public _5 _5() {
-        return tail()._4();
+        return _5;
     }
 
     @Override
-    public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> fmap(MonadicFunction<? super _5, ? extends _5Prime> fn) {
+    public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> fmap(Fn1<? super _5, ? extends _5Prime> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_4Prime> Tuple5<_1, _2, _3, _4Prime, _5> biMapL(MonadicFunction<? super _4, ? extends _4Prime> fn) {
+    public <_4Prime> Tuple5<_1, _2, _3, _4Prime, _5> biMapL(Fn1<? super _4, ? extends _4Prime> fn) {
         return (Tuple5<_1, _2, _3, _4Prime, _5>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> biMapR(MonadicFunction<? super _5, ? extends _5Prime> fn) {
+    public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> biMapR(Fn1<? super _5, ? extends _5Prime> fn) {
         return (Tuple5<_1, _2, _3, _4, _5Prime>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public <_4Prime, _5Prime> Tuple5<_1, _2, _3, _4Prime, _5Prime> biMap(
-            MonadicFunction<? super _4, ? extends _4Prime> lFn,
-            MonadicFunction<? super _5, ? extends _5Prime> rFn) {
+    public <_4Prime, _5Prime> Tuple5<_1, _2, _3, _4Prime, _5Prime> biMap(Fn1<? super _4, ? extends _4Prime> lFn,
+                                                                         Fn1<? super _5, ? extends _5Prime> rFn) {
         return new Tuple5<>(_1(), tail().biMap(lFn, rFn));
     }
 }
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 537f61dc5..ba15852e3 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
@@ -10,12 +10,13 @@
 import java.util.Optional;
 import java.util.function.Consumer;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Map.map;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.singletonMap;
 
 /**
- * A heterogeneous mapping from a parametrized type-safe key to any value, supporting a minimal mapping interface.
+ * An immutable heterogeneous mapping from a parametrized type-safe key to any value, supporting a minimal mapping
+ * interface.
  *
  * @see TypeSafeKey
  * @see com.jnape.palatable.lambda.adt.hlist.HList
@@ -30,31 +31,76 @@ public class HMap implements Iterable<Tuple2<TypeSafeKey, Object>> {
         this.table = table;
     }
 
+    /**
+     * Retrieve the value at this key.
+     *
+     * @param key the key
+     * @param <T> the value type
+     * @return the value at this key wrapped in an {@link Optional}, or {@link Optional#empty}.
+     */
     @SuppressWarnings("unchecked")
     public <T> Optional<T> get(TypeSafeKey<T> key) {
         return Optional.ofNullable((T) table.get(key));
     }
 
-    public <V> V demand(TypeSafeKey<V> key) {
+    /**
+     * Retrieve the value at this key, throwing a {@link NoSuchElementException} if this key is unmapped.
+     *
+     * @param key the key
+     * @param <V> the value type
+     * @return the value at this key
+     * @throws NoSuchElementException if the key is unmapped
+     */
+    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."));
     }
 
+    /**
+     * Store a value for the given key.
+     *
+     * @param key   the key
+     * @param value the value
+     * @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));
     }
 
+    /**
+     * Store all the key/value mappings in <code>hMap</code> in this HMap.
+     *
+     * @param hMap the other hMap
+     * @return the updated HMap
+     */
     public HMap putAll(HMap hMap) {
         return alter(t -> t.putAll(hMap.table));
     }
 
+    /**
+     * Determine if a key is mapped.
+     *
+     * @param key the key
+     * @return true if the key is mapped; false otherwise
+     */
     public boolean containsKey(TypeSafeKey key) {
         return table.containsKey(key);
     }
 
+    /**
+     * Retrieve all the mapped keys.
+     *
+     * @return an Iterable of all the mapped keys
+     */
     public Iterable<TypeSafeKey> keys() {
         return map(Tuple2::_1, this);
     }
 
+    /**
+     * Retrieve all the mapped values.
+     *
+     * @return an Iterable of all the mapped values
+     */
     public Iterable<Object> values() {
         return map(Tuple2::_2, this);
     }
@@ -91,19 +137,57 @@ private HMap alter(Consumer<Map<TypeSafeKey, Object>> alterFn) {
         return new HMap(copy);
     }
 
+    /**
+     * Static factory method for creating an empty HMap.
+     *
+     * @return an empty HMap
+     */
     public static HMap emptyHMap() {
         return EMPTY;
     }
 
+    /**
+     * Static factory method for creating a singleton HMap.
+     *
+     * @param key   the only mapped key
+     * @param value the only mapped value
+     * @param <V>   the only mapped value type
+     * @return a singleton HMap
+     */
     public static <V> HMap singletonHMap(TypeSafeKey<V> key, V value) {
         return new HMap(singletonMap(key, value));
     }
 
+    /**
+     * Static factory method for creating an HMap from two given associations.
+     *
+     * @param key1   the first mapped key
+     * @param value1 the value mapped at key1
+     * @param key2   the second mapped key
+     * @param value2 the value mapped at key2
+     * @param <V1>   value1's type
+     * @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) {
         return singletonHMap(key1, value1).put(key2, value2);
     }
 
+    /**
+     * Static factory method for creating an HMap from three given associations.
+     *
+     * @param key1   the first mapped key
+     * @param value1 the value mapped at key1
+     * @param key2   the second mapped key
+     * @param value2 the value mapped at key2
+     * @param key3   the third mapped key
+     * @param value3 the value mapped at key3
+     * @param <V1>   value1's type
+     * @param <V2>   value2's type
+     * @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) {
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 f4d27566b..d62178132 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
@@ -13,6 +13,12 @@
 @SuppressWarnings("unused")
 public interface TypeSafeKey<T> {
 
+    /**
+     * Static factory method for creating a unique type-safe key
+     *
+     * @param <T> the type of value stored at this key
+     * @return a unique type-safe key
+     */
     static <T> TypeSafeKey<T> typeSafeKey() {
         return new TypeSafeKey<T>() {
         };
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java
deleted file mode 100644
index b599cf797..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.jnape.palatable.lambda.functions;
-
-import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functor.Profunctor;
-
-/**
- * A function taking two arguments. Auto-curried.
- *
- * @param <A> The first argument type
- * @param <B> The second argument type
- * @param <C> The return type
- * @see MonadicFunction
- * @see com.jnape.palatable.lambda.functions.builtin.dyadic.Partial2
- */
-@FunctionalInterface
-public interface DyadicFunction<A, B, C> extends MonadicFunction<A, MonadicFunction<B, C>>, Profunctor<B, C> {
-
-    C apply(A a, B b);
-
-    @Override
-    default MonadicFunction<B, C> apply(A a) {
-        return (b) -> apply(a, b);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    default <C1> DyadicFunction<A, C1, C> diMapL(MonadicFunction<? super C1, ? extends B> fn) {
-        return (DyadicFunction<A, C1, C>) Profunctor.super.diMapL(fn);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    default <C1> DyadicFunction<A, B, C1> diMapR(MonadicFunction<? super C, ? extends C1> fn) {
-        return (DyadicFunction<A, B, C1>) Profunctor.super.diMapR(fn);
-    }
-
-    @Override
-    default <D, E> DyadicFunction<A, D, E> diMap(MonadicFunction<? super D, ? extends B> f1,
-                                                 MonadicFunction<? super C, ? extends E> f2) {
-        return (a, d) -> f2.apply(apply(a, f1.apply(d)));
-    }
-
-    default DyadicFunction<B, A, C> flip() {
-        return (b, a) -> apply(a, b);
-    }
-
-    default MonadicFunction<Tuple2<A, B>, C> uncurry() {
-        return (ab) -> apply(ab._1(), ab._2());
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
new file mode 100644
index 000000000..a5eda64ea
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
@@ -0,0 +1,116 @@
+package com.jnape.palatable.lambda.functions;
+
+import com.jnape.palatable.lambda.functor.Functor;
+import com.jnape.palatable.lambda.functor.Profunctor;
+
+import java.util.function.Function;
+
+/**
+ * A function taking a single argument. This is the core function type that all other function types extend and
+ * auto-curry with.
+ *
+ * @param <A> The argument type
+ * @param <B> The result type
+ */
+@FunctionalInterface
+public interface Fn1<A, B> extends Functor<B>, Profunctor<A, B>, Function<A, B> {
+
+    /**
+     * Invoke this function with the given argument.
+     *
+     * @param a the argument
+     * @return the result of the function application
+     */
+    B apply(A a);
+
+    /**
+     * Left-to-right composition, such that <code>g.then(f).apply(x)</code> is equivalent to
+     * <code>f.apply(g.apply(x))</code>.
+     *
+     * @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
+     */
+    default <C> Fn1<A, C> then(Fn1<? super B, ? extends C> f) {
+        return fmap(f);
+    }
+
+    /**
+     * Also left-to-right composition (<a href="http://jnape.com/the-perils-of-implementing-functor-in-java/">sadly</a>).
+     *
+     * @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
+     * @see Fn1#then(Fn1)
+     */
+    @Override
+    default <C> Fn1<A, C> fmap(Fn1<? super B, ? extends C> f) {
+        return a -> f.apply(apply(a));
+    }
+
+    /**
+     * Contravariantly map over the argument to this function, producing a function that takes the new argument type,
+     * and produces the same result.
+     *
+     * @param fn  the contravariant argument mapping function
+     * @param <Z> the new argument type
+     * @return a new function from Z (the new argument type) to B (the same result)
+     */
+    @Override
+    default <Z> Fn1<Z, B> diMapL(Fn1<Z, A> fn) {
+        return (Fn1<Z, B>) Profunctor.super.diMapL(fn);
+    }
+
+    /**
+     * Covariantly map over the return value of this function, producing a function that takes the same argument, and
+     * produces the new result type.
+     *
+     * @param fn  the covariant result mapping function
+     * @param <C> the new result type
+     * @return a new function from A (the same argument type) to C (the new result type)
+     */
+    @Override
+    default <C> Fn1<A, C> diMapR(Fn1<B, C> fn) {
+        return (Fn1<A, C>) Profunctor.super.diMapR(fn);
+    }
+
+    /**
+     * Exercise both <code>diMapL</code> and <code>diMapR</code> over this function in the same invocation.
+     *
+     * @param lFn the contravariant argument mapping function
+     * @param rFn the covariant result mapping function
+     * @param <Z> the new argument type
+     * @param <C> the new result type
+     * @return a new function from Z (the new argument type) to C (the new result type)
+     */
+    @Override
+    default <Z, C> Fn1<Z, C> diMap(Fn1<Z, A> lFn, Fn1<B, C> rFn) {
+        return lFn.andThen(this).andThen(rFn);
+    }
+
+    /**
+     * Override of {@link Function#compose(Function)}, returning an instance of <code>Fn1</code> for compatibility.
+     * Right-to-left composition.
+     *
+     * @param before the function who's return value is this function's argument
+     * @param <Z>    the new argument type
+     * @return a new function from Z (the new argument type) to B (the same result type)
+     */
+    @Override
+    default <Z> Fn1<Z, B> compose(Function<? super Z, ? extends A> before) {
+        return z -> apply(before.apply(z));
+    }
+
+    /**
+     * Override of {@link Function#andThen(Function)}, returning an instance of <code>Fn1</code> for compatibility.
+     * Left-to-right composition.
+     *
+     * @param after the function to invoke on this function's return value
+     * @param <C>   the new result type
+     * @return a new function from A (the same argument type) to C (the new result type)
+     */
+    @Override
+    default <C> Fn1<A, C> andThen(Function<? super B, ? extends C> after) {
+        return a -> after.apply(apply(a));
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
new file mode 100644
index 000000000..5f9b6677b
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
@@ -0,0 +1,56 @@
+package com.jnape.palatable.lambda.functions;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+
+/**
+ * A function taking two arguments. Note that defining <code>Fn2</code> in terms of <code>Fn1</code> provides a
+ * reasonable approximation of currying in the form of multiple <code>apply</code> overloads that take different numbers
+ * of arguments.
+ *
+ * @param <A> The first argument type
+ * @param <B> The second argument type
+ * @param <C> The return type
+ * @see Fn1
+ * @see com.jnape.palatable.lambda.functions.builtin.fn2.Partial2
+ */
+@FunctionalInterface
+public interface Fn2<A, B, C> extends Fn1<A, Fn1<B, C>> {
+
+    /**
+     * Invoke this function with the given arguments.
+     *
+     * @param a the first argument
+     * @param b the second argument
+     * @return the result of the function application
+     */
+    C apply(A a, B b);
+
+    /**
+     * Partially apply this function by passing its first argument.
+     *
+     * @param a the first argument
+     * @return an Fn1 that takes the second argument and returns the result
+     */
+    @Override
+    default Fn1<B, C> apply(A a) {
+        return (b) -> apply(a, b);
+    }
+
+    /**
+     * Flip the order of the arguments.
+     *
+     * @return an Fn2 that takes the first and second arguments in reversed order
+     */
+    default Fn2<B, A, C> flip() {
+        return (b, a) -> apply(a, b);
+    }
+
+    /**
+     * Returns an <code>Fn1</code> that takes the arguments as a <code>Tuple2&lt;A, B&gt;</code>.
+     *
+     * @return an Fn1 taking a Tuple2
+     */
+    default Fn1<Tuple2<A, B>, C> uncurry() {
+        return (ab) -> apply(ab._1(), ab._2());
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java
new file mode 100644
index 000000000..6efb9bb1b
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java
@@ -0,0 +1,71 @@
+package com.jnape.palatable.lambda.functions;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+
+/**
+ * A function taking three arguments. Defined in terms of <code>Fn2</code>, so similarly auto-curried.
+ *
+ * @param <A> The first argument type
+ * @param <B> The second argument type
+ * @param <C> The third argument type
+ * @param <D> The return type
+ * @see Fn2
+ * @see com.jnape.palatable.lambda.functions.builtin.fn2.Partial3
+ */
+@FunctionalInterface
+public interface Fn3<A, B, C, D> extends Fn2<A, B, Fn1<C, D>> {
+
+    /**
+     * Invoke this function with the given arguments.
+     *
+     * @param a the first argument
+     * @param b the second argument
+     * @param c the third argument
+     * @return the result of the function application
+     */
+    D apply(A a, B b, C c);
+
+    /**
+     * Partially apply this function by taking its first argument.
+     *
+     * @param a the first argument
+     * @return an Fn2 that takes the second and third argument and returns the result
+     */
+    @Override
+    default Fn2<B, C, D> apply(A a) {
+        return (b, c) -> apply(a, b, c);
+    }
+
+    /**
+     * Partially apply this function by taking its first two arguments.
+     *
+     * @param a the first argument
+     * @param b the second argument
+     * @return an Fn1 that takes the third argument and returns the result
+     */
+    @Override
+    default Fn1<C, D> apply(A a, B b) {
+        return (c) -> apply(a, b, c);
+    }
+
+    /**
+     * Flip the order of the first two arguments.
+     *
+     * @return an Fn3 that takes the first and second arguments in reversed order
+     */
+    @Override
+    default Fn3<B, A, C, D> flip() {
+        return (b, a, c) -> apply(a, b, c);
+    }
+
+    /**
+     * Returns an <code>Fn2</code> that takes the first two arguments as a <code>Tuple2&lt;A, B&gt;</code> and the third
+     * argument.
+     *
+     * @return an Fn2 taking a Tuple2 and the third argument
+     */
+    @Override
+    default Fn2<Tuple2<A, B>, C, D> uncurry() {
+        return (ab, c) -> apply(ab._1(), ab._2(), c);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java
deleted file mode 100644
index dddd2ec8c..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package com.jnape.palatable.lambda.functions;
-
-import com.jnape.palatable.lambda.functor.Functor;
-
-import java.util.function.Function;
-
-/**
- * A function taking a single argument. This is the core function type that all other function types extend and
- * auto-curry with.
- *
- * @param <A> The input type
- * @param <B> The output type
- */
-@FunctionalInterface
-public interface MonadicFunction<A, B> extends Functor<B>, Function<A, B> {
-
-    B apply(A a);
-
-    default <C> MonadicFunction<A, C> then(MonadicFunction<? super B, ? extends C> g) {
-        return fmap(g);
-    }
-
-    @Override
-    default <C> MonadicFunction<A, C> fmap(MonadicFunction<? super B, ? extends C> g) {
-        return a -> g.apply(apply(a));
-    }
-
-    @Override
-    default <Z> MonadicFunction<Z, B> compose(Function<? super Z, ? extends A> before) {
-        return z -> apply(before.apply(z));
-    }
-
-    @Override
-    default <C> MonadicFunction<A, C> andThen(Function<? super B, ? extends C> after) {
-        return a -> after.apply(apply(a));
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/TriadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/TriadicFunction.java
deleted file mode 100644
index 72423cead..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/TriadicFunction.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.jnape.palatable.lambda.functions;
-
-import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-
-/**
- * A function taking three arguments. Auto-curried
- *
- * @param <A> The first argument type
- * @param <B> The second argument type
- * @param <C> The third argument type
- * @param <D> The return type
- * @see DyadicFunction
- * @see com.jnape.palatable.lambda.functions.builtin.dyadic.Partial3
- */
-@FunctionalInterface
-public interface TriadicFunction<A, B, C, D> extends DyadicFunction<A, B, MonadicFunction<C, D>> {
-
-    D apply(A a, B b, C c);
-
-    @Override
-    default DyadicFunction<B, C, D> apply(A a) {
-        return (b, c) -> apply(a, b, c);
-    }
-
-    @Override
-    default MonadicFunction<C, D> apply(A a, B b) {
-        return (c) -> apply(a, b, c);
-    }
-
-    @Override
-    default TriadicFunction<B, A, C, D> flip() {
-        return (b, a, c) -> apply(a, b, c);
-    }
-
-    @Override
-    default DyadicFunction<Tuple2<A, B>, C, D> uncurry() {
-        return (ab, c) -> apply(ab._1(), ab._2(), c);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Map.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Map.java
deleted file mode 100644
index 47e77e3b8..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Map.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-import com.jnape.palatable.lambda.iterators.MappingIterator;
-
-/**
- * Lazily apply a function to each element in an <code>Iterable</code>, producing an <code>Iterable</code> of the mapped
- * results.
- *
- * @param <A> A type contravariant to the input Iterable element type
- * @param <B> A type covariant to the output Iterable element type
- */
-public final class Map<A, B> implements DyadicFunction<MonadicFunction<? super A, ? extends B>, Iterable<A>, Iterable<B>> {
-
-    private Map() {
-    }
-
-    @Override
-    public Iterable<B> apply(MonadicFunction<? super A, ? extends B> function, Iterable<A> as) {
-        return () -> new MappingIterator<>(function, as.iterator());
-    }
-
-    public static <A, B> Map<A, B> map() {
-        return new Map<>();
-    }
-
-    public static <A, B> MonadicFunction<Iterable<A>, Iterable<B>> map(
-            MonadicFunction<? super A, ? extends B> function) {
-        return Map.<A, B>map().apply(function);
-    }
-
-    public static <A, B> Iterable<B> map(MonadicFunction<? super A, ? extends B> function, Iterable<A> as) {
-        return Map.<A, B>map(function).apply(as);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2.java
deleted file mode 100644
index 2990dac51..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-
-/**
- * Partially apply (fix) the first argument of a <code>DyadicFunction</code>, producing a <code>MonadicFunction</code>
- * that takes the remaining argument. This is isomorphic to calling {@link com.jnape.palatable.lambda.functions.DyadicFunction#apply(Object)}.
- *
- * @param <A> The type of the value to be supplied
- * @param <B> The input argument type of the resulting function
- * @param <C> The return type of the resulting function
- * @see Partial3
- */
-public final class Partial2<A, B, C> implements DyadicFunction<DyadicFunction<A, B, C>, A, MonadicFunction<B, C>> {
-
-    private Partial2() {
-    }
-
-    @Override
-    public MonadicFunction<B, C> apply(DyadicFunction<A, B, C> function, A a) {
-        return function.apply(a);
-    }
-
-    public static <A, B, C> Partial2<DyadicFunction<A, B, C>, A, MonadicFunction<B, C>> partial2() {
-        return new Partial2<>();
-    }
-
-    public static <A, B, C> MonadicFunction<A, MonadicFunction<B, C>> partial2(DyadicFunction<A, B, C> function) {
-        return Partial2.<A, B, C>partial2().apply(new Partial2<>(), function);
-    }
-
-    public static <A, B, C> MonadicFunction<B, C> partial2(DyadicFunction<A, B, C> function, A a) {
-        return partial2(function).apply(a);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3.java
deleted file mode 100644
index cb1423b01..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-import com.jnape.palatable.lambda.functions.TriadicFunction;
-
-/**
- * Partially apply (fix) the first argument of a <code>TriadicFunction</code>, producing a <code>DyadicFunction</code>
- * that takes the remaining two argument. This is isomorphic to calling {@link com.jnape.palatable.lambda.functions.TriadicFunction#apply(Object)}.
- *
- * @param <A> The type of the value to be supplied
- * @param <B> The first input argument type of the resulting function
- * @param <C> The second input argument type of the resulting function
- * @param <D> The return type of the resulting function
- * @see Partial2
- */
-public final class Partial3<A, B, C, D> implements DyadicFunction<TriadicFunction<A, B, C, D>, A, DyadicFunction<B, C, D>> {
-
-    private Partial3() {
-    }
-
-    @Override
-    public DyadicFunction<B, C, D> apply(TriadicFunction<A, B, C, D> function, A a) {
-        return function.apply(a);
-    }
-
-    public static <A, B, C, D> Partial3<A, B, C, D> partial3() {
-        return new Partial3<>();
-    }
-
-    public static <A, B, C, D> MonadicFunction<A, DyadicFunction<B, C, D>> partial3(
-            TriadicFunction<A, B, C, D> function) {
-        return Partial3.<A, B, C, D>partial3().apply(function);
-    }
-
-    public static <A, B, C, D> DyadicFunction<B, C, D> partial3(TriadicFunction<A, B, C, D> function, A a) {
-        return partial3(function).apply(a);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeft.java
deleted file mode 100644
index 40615afbb..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeft.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-
-import java.util.Iterator;
-import java.util.Optional;
-
-import static com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft.foldLeft;
-
-/**
- * Given an <code>Iterable</code> of <code>A</code>s and a <code>{@link DyadicFunction}&lt;A, A, A&gt;</code>,
- * iteratively accumulate over the <code>Iterable</code>, returning an <code>Optional&lt;A&gt;</code> (if the
- * <code>Iterable</code> is empty, the result is <code>Optional.empty()</code>; otherwise, the result is wrapped in
- * <code>Optional.of()</code>. For this reason, <code>null</code> accumulation results are considered erroneous and will
- * throw.
- * <p>
- * This function is isomorphic to a left fold over the <code>Iterable</code> where the head element is the starting
- * accumulation value and the result is lifted into an <code>Optional</code>.
- *
- * @param <A> The input Iterable element type, as well as the accumulation type
- * @see ReduceRight
- * @see com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft
- */
-public final class ReduceLeft<A> implements DyadicFunction<DyadicFunction<? super A, ? super A, ? extends A>, Iterable<A>, Optional<A>> {
-
-    private ReduceLeft() {
-    }
-
-    @Override
-    public Optional<A> apply(DyadicFunction<? super A, ? super A, ? extends A> function, Iterable<A> as) {
-        Iterator<A> iterator = as.iterator();
-        if (!iterator.hasNext())
-            return Optional.empty();
-
-        return Optional.of(foldLeft(function, iterator.next(), () -> iterator));
-    }
-
-    public static <A> ReduceLeft<A> reduceLeft() {
-        return new ReduceLeft<>();
-    }
-
-    public static <A> MonadicFunction<Iterable<A>, Optional<A>> reduceLeft(
-            DyadicFunction<? super A, ? super A, ? extends A> function) {
-        return ReduceLeft.<A>reduceLeft().apply(function);
-    }
-
-    public static <A> Optional<A> reduceLeft(DyadicFunction<? super A, ? super A, ? extends A> function,
-                                             Iterable<A> as) {
-        return ReduceLeft.<A>reduceLeft(function).apply(as);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRight.java
deleted file mode 100644
index 30606f018..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRight.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-
-import java.util.Optional;
-
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.ReduceLeft.reduceLeft;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Reverse.reverse;
-
-/**
- * Given an <code>Iterable</code> of <code>A</code>s and a <code>{@link DyadicFunction}&lt;A, A, A&gt;</code>,
- * iteratively accumulate over the <code>Iterable</code>, returning an <code>Optional&lt;A&gt;
- * </code> (if the
- * <code>Iterable</code> is empty, the result is <code>Optional.empty()</code>; otherwise, the result is wrapped in
- * <code>Optional.of()</code>. For this reason, <code>null</code> accumulation results are considered erroneous and will
- * throw.
- * <p>
- * This function is isomorphic to a right fold over the <code>Iterable</code> where the tail element is the starting
- * accumulation value and the result is lifted into an <code>Optional</code>.
- *
- * @param <A> The input Iterable element type, as well as the accumulation type
- * @see ReduceLeft
- * @see com.jnape.palatable.lambda.functions.builtin.triadic.FoldRight
- */
-public final class ReduceRight<A> implements DyadicFunction<DyadicFunction<? super A, ? super A, ? extends A>, Iterable<A>, Optional<A>> {
-
-    private ReduceRight() {
-    }
-
-    @Override
-    public final Optional<A> apply(DyadicFunction<? super A, ? super A, ? extends A> function, Iterable<A> as) {
-        return reduceLeft(function.flip(), reverse(as));
-    }
-
-    public static <A> ReduceRight<A> reduceRight() {
-        return new ReduceRight<>();
-    }
-
-    public static <A> MonadicFunction<Iterable<A>, Optional<A>> reduceRight(
-            DyadicFunction<? super A, ? super A, ? extends A> function) {
-        return ReduceRight.<A>reduceRight().apply(function);
-    }
-
-    public static <A> Optional<A> reduceRight(DyadicFunction<? super A, ? super A, ? extends A> function,
-                                              Iterable<A> as) {
-        return ReduceRight.<A>reduceRight(function).apply(as);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Constantly.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Constantly.java
new file mode 100644
index 000000000..fb034b3fe
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Constantly.java
@@ -0,0 +1,33 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+/**
+ * A function that takes two arguments and always returns the first argument.
+ *
+ * @param <A> The first argument type, and the the function's return type
+ * @param <B> The second (ignored) argument type
+ */
+public final class Constantly<A, B> implements Fn2<A, B, A> {
+
+    private Constantly() {
+    }
+
+    @Override
+    public A apply(A a, B b) {
+        return a;
+    }
+
+    public static <A, B> Constantly<A, B> constantly() {
+        return new Constantly<>();
+    }
+
+    public static <A, B> Fn1<B, A> constantly(A a) {
+        return Constantly.<A, B>constantly().apply(a);
+    }
+
+    public static <A, B> A constantly(A a, B b) {
+        return constantly(a).apply(b);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java
similarity index 77%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java
index cc1694f79..8f626dd33 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
+package com.jnape.palatable.lambda.functions.builtin.fn1;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.iterators.CyclicIterator;
 
 import static java.util.Arrays.asList;
@@ -11,7 +11,10 @@
  *
  * @param <A> The Iterable element type
  */
-public final class Cycle<A> implements MonadicFunction<Iterable<A>, Iterable<A>> {
+public final class Cycle<A> implements Fn1<Iterable<A>, Iterable<A>> {
+
+    private Cycle() {
+    }
 
     @Override
     public Iterable<A> apply(Iterable<A> as) {
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Id.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Id.java
new file mode 100644
index 000000000..7bba0f7f7
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Id.java
@@ -0,0 +1,26 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+
+/**
+ * The identity function.
+ *
+ * @param <A> The input/output type
+ */
+public final class Id<A> implements Fn1<A, A> {
+
+    private static final Id ID = new Id();
+
+    private Id() {
+    }
+
+    @Override
+    public A apply(A a) {
+        return a;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Id<A> id() {
+        return (Id<A>) ID;
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java
similarity index 71%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java
index 9f06e6e64..6e1547155 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
+package com.jnape.palatable.lambda.functions.builtin.fn1;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.iterators.RepetitiousIterator;
 
 /**
@@ -8,7 +8,10 @@
  *
  * @param <A> The Iterable element type
  */
-public final class Repeat<A> implements MonadicFunction<A, Iterable<A>> {
+public final class Repeat<A> implements Fn1<A, Iterable<A>> {
+
+    private Repeat() {
+    }
 
     @Override
     public Iterable<A> apply(A a) {
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java
similarity index 75%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java
index ad15f59c0..51637ce0d 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
+package com.jnape.palatable.lambda.functions.builtin.fn1;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.iterators.ReversingIterator;
 
 /**
@@ -9,7 +9,10 @@
  *
  * @param <A> The Iterable element type
  */
-public final class Reverse<A> implements MonadicFunction<Iterable<A>, Iterable<A>> {
+public final class Reverse<A> implements Fn1<Iterable<A>, Iterable<A>> {
+
+    private Reverse() {
+    }
 
     @Override
     public Iterable<A> apply(Iterable<A> as) {
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java
similarity index 52%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java
index 768a76b0b..d3d96ccb4 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 
 /**
  * Eagerly apply a predicate to each element in an <code>Iterable</code>, returning <code>true</code> if every element
@@ -11,13 +11,13 @@
  * @param <A> The input Iterable element type
  * @see Any
  */
-public final class All<A> implements DyadicFunction<MonadicFunction<? super A, Boolean>, Iterable<A>, Boolean> {
+public final class All<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Boolean> {
 
     private All() {
     }
 
     @Override
-    public Boolean apply(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public Boolean apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         for (A a : as)
             if (!predicate.apply(a))
                 return false;
@@ -29,11 +29,11 @@ public static <A> All<A> all() {
         return new All<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Boolean> all(MonadicFunction<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Boolean> all(Fn1<? super A, Boolean> predicate) {
         return All.<A>all().apply(predicate);
     }
 
-    public static <A> boolean all(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Boolean all(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return All.<A>all(predicate).apply(as);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Any.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java
similarity index 52%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Any.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java
index 110111adb..37a83bbe6 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Any.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 
 /**
  * Eagerly apply a predicate to each element in an <code>Iterable</code>, returning <code>true</code> if any element
@@ -11,13 +11,13 @@
  * @param <A> The input Iterable element type
  * @see All
  */
-public final class Any<A> implements DyadicFunction<MonadicFunction<? super A, Boolean>, Iterable<A>, Boolean> {
+public final class Any<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Boolean> {
 
     private Any() {
     }
 
     @Override
-    public Boolean apply(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public Boolean apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         for (A a : as)
             if (predicate.apply(a))
                 return true;
@@ -29,11 +29,11 @@ public static <A> Any<A> any() {
         return new Any<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Boolean> any(MonadicFunction<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Boolean> any(Fn1<? super A, Boolean> predicate) {
         return Any.<A>any().apply(predicate);
     }
 
-    public static <A> Boolean any(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Boolean any(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return Any.<A>any(predicate).apply(as);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProduct.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java
similarity index 78%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProduct.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java
index 29d2846a6..40da00035 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProduct.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java
@@ -1,8 +1,8 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.CombinatorialIterator;
 
 /**
@@ -19,7 +19,7 @@
  * @param <B> The multiplier Iterable element type
  * @see Zip
  */
-public final class CartesianProduct<A, B> implements DyadicFunction<Iterable<A>, Iterable<B>, Iterable<Tuple2<A, B>>> {
+public final class CartesianProduct<A, B> implements Fn2<Iterable<A>, Iterable<B>, Iterable<Tuple2<A, B>>> {
 
     private CartesianProduct() {
     }
@@ -33,7 +33,7 @@ public static <A, B> CartesianProduct<A, B> cartesianProduct() {
         return new CartesianProduct<>();
     }
 
-    public static <A, B> MonadicFunction<Iterable<B>, Iterable<Tuple2<A, B>>> cartesianProduct(Iterable<A> as) {
+    public static <A, B> Fn1<Iterable<B>, Iterable<Tuple2<A, B>>> cartesianProduct(Iterable<A> as) {
         return CartesianProduct.<A, B>cartesianProduct().apply(as);
     }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Drop.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java
similarity index 71%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Drop.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java
index 537fa015e..4a25573d3 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Drop.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.DroppingIterator;
 
 /**
@@ -13,7 +13,7 @@
  * @see DropWhile
  * @see Take
  */
-public final class Drop<A> implements DyadicFunction<Integer, Iterable<A>, Iterable<A>> {
+public final class Drop<A> implements Fn2<Integer, Iterable<A>, Iterable<A>> {
 
     private Drop() {
     }
@@ -27,7 +27,7 @@ public static <A> Drop<A> drop() {
         return new Drop<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Iterable<A>> drop(int n) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> drop(int n) {
         return Drop.<A>drop().apply(n);
     }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
similarity index 53%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhile.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
index 676eef969..59be5363e 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhile.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.PredicatedDroppingIterator;
 
 /**
@@ -14,13 +14,13 @@
  * @see TakeWhile
  */
 
-public final class DropWhile<A> implements DyadicFunction<MonadicFunction<? super A, Boolean>, Iterable<A>, Iterable<A>> {
+public final class DropWhile<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Iterable<A>> {
 
     private DropWhile() {
     }
 
     @Override
-    public Iterable<A> apply(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public Iterable<A> apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return () -> new PredicatedDroppingIterator<>(predicate, as.iterator());
     }
 
@@ -28,12 +28,11 @@ public static <A> DropWhile<A> dropWhile() {
         return new DropWhile<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Iterable<A>> dropWhile(
-            MonadicFunction<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> dropWhile(Fn1<? super A, Boolean> predicate) {
         return DropWhile.<A>dropWhile().apply(predicate);
     }
 
-    public static <A> Iterable<A> dropWhile(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Iterable<A> dropWhile(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return DropWhile.<A>dropWhile(predicate).apply(as);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Filter.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
similarity index 55%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Filter.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
index 394faf487..2b6d7c610 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Filter.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.FilteringIterator;
 
 /**
@@ -12,13 +12,13 @@
  * @see TakeWhile
  * @see DropWhile
  */
-public final class Filter<A> implements DyadicFunction<MonadicFunction<? super A, Boolean>, Iterable<A>, Iterable<A>> {
+public final class Filter<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Iterable<A>> {
 
     private Filter() {
     }
 
     @Override
-    public Iterable<A> apply(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public Iterable<A> apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return () -> new FilteringIterator<>(predicate, as.iterator());
     }
 
@@ -26,11 +26,11 @@ public static <A> Filter<A> filter() {
         return new Filter<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Iterable<A>> filter(MonadicFunction<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> filter(Fn1<? super A, Boolean> predicate) {
         return Filter.<A>filter().apply(predicate);
     }
 
-    public static <A> Iterable<A> filter(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Iterable<A> filter(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return Filter.<A>filter(predicate).apply(as);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOf.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java
similarity index 71%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOf.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java
index f2438aead..f990ecab2 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOf.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.GroupingIterator;
 
 /**
@@ -12,7 +12,7 @@
  *
  * @param <A> The Iterable element type
  */
-public final class InGroupsOf<A> implements DyadicFunction<Integer, Iterable<A>, Iterable<Iterable<A>>> {
+public final class InGroupsOf<A> implements Fn2<Integer, Iterable<A>, Iterable<Iterable<A>>> {
 
     private InGroupsOf() {
     }
@@ -26,7 +26,7 @@ public static <A> InGroupsOf<A> inGroupsOf() {
         return new InGroupsOf<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Iterable<Iterable<A>>> inGroupsOf(Integer k) {
+    public static <A> Fn1<Iterable<A>, Iterable<Iterable<A>>> inGroupsOf(Integer k) {
         return InGroupsOf.<A>inGroupsOf().apply(k);
     }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Iterate.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java
similarity index 60%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Iterate.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java
index 3e4330f5f..8a7209567 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Iterate.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.UnfoldingIterator;
 
 import java.util.Optional;
@@ -15,13 +15,13 @@
  *
  * @param <A> The Iterable element type
  */
-public final class Iterate<A> implements DyadicFunction<MonadicFunction<? super A, ? extends A>, A, Iterable<A>> {
+public final class Iterate<A> implements Fn2<Fn1<? super A, ? extends A>, A, Iterable<A>> {
 
     private Iterate() {
     }
 
     @Override
-    public Iterable<A> apply(MonadicFunction<? super A, ? extends A> fn, A seed) {
+    public Iterable<A> apply(Fn1<? super A, ? extends A> fn, A seed) {
         return () -> new UnfoldingIterator<>(a -> Optional.of(tuple(a, fn.apply(a))), seed);
     }
 
@@ -29,11 +29,11 @@ public static <A> Iterate<A> iterate() {
         return new Iterate<>();
     }
 
-    public static <A> MonadicFunction<A, Iterable<A>> iterate(MonadicFunction<? super A, ? extends A> fn) {
+    public static <A> Fn1<A, Iterable<A>> iterate(Fn1<? super A, ? extends A> fn) {
         return Iterate.<A>iterate().apply(fn);
     }
 
-    public static <A> Iterable<A> iterate(MonadicFunction<? super A, ? extends A> fn, A seed) {
+    public static <A> Iterable<A> iterate(Fn1<? super A, ? extends A> fn, A seed) {
         return Iterate.<A>iterate(fn).apply(seed);
     }
 }
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
new file mode 100644
index 000000000..3aecce3a5
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java
@@ -0,0 +1,35 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.iterators.MappingIterator;
+
+/**
+ * Lazily apply a function to each element in an <code>Iterable</code>, producing an <code>Iterable</code> of the mapped
+ * results.
+ *
+ * @param <A> A type contravariant to the input Iterable element type
+ * @param <B> A type covariant to the output Iterable element type
+ */
+public final class Map<A, B> implements Fn2<Fn1<? super A, ? extends B>, Iterable<A>, Iterable<B>> {
+
+    private Map() {
+    }
+
+    @Override
+    public Iterable<B> apply(Fn1<? super A, ? extends B> fn, Iterable<A> as) {
+        return () -> new MappingIterator<>(fn, as.iterator());
+    }
+
+    public static <A, B> Map<A, B> map() {
+        return new Map<>();
+    }
+
+    public static <A, B> Fn1<Iterable<A>, Iterable<B>> map(Fn1<? super A, ? extends B> fn) {
+        return Map.<A, B>map().apply(fn);
+    }
+
+    public static <A, B> Iterable<B> map(Fn1<? super A, ? extends B> fn, Iterable<A> as) {
+        return Map.<A, B>map(fn).apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2.java
new file mode 100644
index 000000000..a7292ad93
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2.java
@@ -0,0 +1,36 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+/**
+ * Partially apply (fix) the first argument of a <code>Fn2</code>, producing a <code>Fn1</code> that takes the remaining
+ * argument. This is isomorphic to calling {@link Fn2#apply(Object)}.
+ *
+ * @param <A> The type of the value to be supplied
+ * @param <B> The input argument type of the resulting function
+ * @param <C> The return type of the resulting function
+ * @see Partial3
+ */
+public final class Partial2<A, B, C> implements Fn2<Fn2<A, B, C>, A, Fn1<B, C>> {
+
+    private Partial2() {
+    }
+
+    @Override
+    public Fn1<B, C> apply(Fn2<A, B, C> fn, A a) {
+        return fn.apply(a);
+    }
+
+    public static <A, B, C> Partial2<Fn2<A, B, C>, A, Fn1<B, C>> partial2() {
+        return new Partial2<>();
+    }
+
+    public static <A, B, C> Fn1<A, Fn1<B, C>> partial2(Fn2<A, B, C> fn) {
+        return Partial2.<A, B, C>partial2().apply(new Partial2<>(), fn);
+    }
+
+    public static <A, B, C> Fn1<B, C> partial2(Fn2<A, B, C> fn, A a) {
+        return partial2(fn).apply(a);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3.java
new file mode 100644
index 000000000..8cf530b6e
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3.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 com.jnape.palatable.lambda.functions.Fn3;
+
+/**
+ * Partially apply (fix) the first argument of a <code>Fn3</code>, producing a <code>Fn2</code> that takes the remaining
+ * two argument. This is isomorphic to calling {@link Fn3#apply(Object)}.
+ *
+ * @param <A> The type of the value to be supplied
+ * @param <B> The first input argument type of the resulting function
+ * @param <C> The second input argument type of the resulting function
+ * @param <D> The return type of the resulting function
+ * @see Partial2
+ */
+public final class Partial3<A, B, C, D> implements Fn2<Fn3<A, B, C, D>, A, Fn2<B, C, D>> {
+
+    private Partial3() {
+    }
+
+    @Override
+    public Fn2<B, C, D> apply(Fn3<A, B, C, D> fn, A a) {
+        return fn.apply(a);
+    }
+
+    public static <A, B, C, D> Partial3<A, B, C, D> partial3() {
+        return new Partial3<>();
+    }
+
+    public static <A, B, C, D> Fn1<A, Fn2<B, C, D>> partial3(Fn3<A, B, C, D> fn) {
+        return Partial3.<A, B, C, D>partial3().apply(fn);
+    }
+
+    public static <A, B, C, D> Fn2<B, C, D> partial3(Fn3<A, B, C, D> fn, A a) {
+        return partial3(fn).apply(a);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeft.java
new file mode 100644
index 000000000..b493cf5db
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeft.java
@@ -0,0 +1,50 @@
+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.Iterator;
+import java.util.Optional;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft;
+
+/**
+ * Given an <code>Iterable</code> of <code>A</code>s and a <code>{@link Fn2}&lt;A, A, A&gt;</code>, iteratively
+ * accumulate over the <code>Iterable</code>, returning an <code>Optional&lt;A&gt;</code> (if the <code>Iterable</code>
+ * is empty, the result is <code>Optional.empty()</code>; otherwise, the result is wrapped in
+ * <code>Optional.of()</code>. For this reason, <code>null</code> accumulation results are considered erroneous and will
+ * throw.
+ * <p>
+ * This function is isomorphic to a left fold over the <code>Iterable</code> where the head element is the starting
+ * accumulation value and the result is lifted into an <code>Optional</code>.
+ *
+ * @param <A> The input Iterable element type, as well as the accumulation type
+ * @see ReduceRight
+ * @see com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft
+ */
+public final class ReduceLeft<A> implements Fn2<Fn2<? super A, ? super A, ? extends A>, Iterable<A>, Optional<A>> {
+
+    private ReduceLeft() {
+    }
+
+    @Override
+    public Optional<A> apply(Fn2<? super A, ? super A, ? extends A> fn, Iterable<A> as) {
+        Iterator<A> iterator = as.iterator();
+        if (!iterator.hasNext())
+            return Optional.empty();
+
+        return Optional.of(foldLeft(fn, iterator.next(), () -> iterator));
+    }
+
+    public static <A> ReduceLeft<A> reduceLeft() {
+        return new ReduceLeft<>();
+    }
+
+    public static <A> Fn1<Iterable<A>, Optional<A>> reduceLeft(Fn2<? super A, ? super A, ? extends A> fn) {
+        return ReduceLeft.<A>reduceLeft().apply(fn);
+    }
+
+    public static <A> Optional<A> reduceLeft(Fn2<? super A, ? super A, ? extends A> fn, Iterable<A> as) {
+        return ReduceLeft.<A>reduceLeft(fn).apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRight.java
new file mode 100644
index 000000000..1a49359cf
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRight.java
@@ -0,0 +1,46 @@
+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.Optional;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ReduceLeft.reduceLeft;
+
+/**
+ * Given an <code>Iterable</code> of <code>A</code>s and a <code>{@link Fn2}&lt;A, A, A&gt;</code>, iteratively
+ * accumulate over the <code>Iterable</code>, returning an <code>Optional&lt;A&gt; </code> (if the <code>Iterable</code>
+ * is empty, the result is <code>Optional.empty()</code>; otherwise, the result is wrapped in
+ * <code>Optional.of()</code>. For this reason, <code>null</code> accumulation results are considered erroneous and will
+ * throw.
+ * <p>
+ * This function is isomorphic to a right fold over the <code>Iterable</code> where the tail element is the starting
+ * accumulation value and the result is lifted into an <code>Optional</code>.
+ *
+ * @param <A> The input Iterable element type, as well as the accumulation type
+ * @see ReduceLeft
+ * @see com.jnape.palatable.lambda.functions.builtin.fn3.FoldRight
+ */
+public final class ReduceRight<A> implements Fn2<Fn2<? super A, ? super A, ? extends A>, Iterable<A>, Optional<A>> {
+
+    private ReduceRight() {
+    }
+
+    @Override
+    public final Optional<A> apply(Fn2<? super A, ? super A, ? extends A> fn, Iterable<A> as) {
+        return reduceLeft(fn.flip(), reverse(as));
+    }
+
+    public static <A> ReduceRight<A> reduceRight() {
+        return new ReduceRight<>();
+    }
+
+    public static <A> Fn1<Iterable<A>, Optional<A>> reduceRight(Fn2<? super A, ? super A, ? extends A> fn) {
+        return ReduceRight.<A>reduceRight().apply(fn);
+    }
+
+    public static <A> Optional<A> reduceRight(Fn2<? super A, ? super A, ? extends A> fn, Iterable<A> as) {
+        return ReduceRight.<A>reduceRight(fn).apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Take.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java
similarity index 69%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Take.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java
index c0b860ca1..2d095724c 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Take.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.TakingIterator;
 
 /**
@@ -13,7 +13,7 @@
  * @see TakeWhile
  * @see Drop
  */
-public final class Take<A> implements DyadicFunction<Integer, Iterable<A>, Iterable<A>> {
+public final class Take<A> implements Fn2<Integer, Iterable<A>, Iterable<A>> {
 
     private Take() {
     }
@@ -27,7 +27,7 @@ public static <A> Take<A> take() {
         return new Take<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Iterable<A>> take(int n) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> take(int n) {
         return Take.<A>take().apply(n);
     }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
similarity index 53%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhile.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
index 335983e6e..8cec722e5 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhile.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.PredicatedTakingIterator;
 
 /**
@@ -13,13 +13,13 @@
  * @see Filter
  * @see DropWhile
  */
-public final class TakeWhile<A> implements DyadicFunction<MonadicFunction<? super A, Boolean>, Iterable<A>, Iterable<A>> {
+public final class TakeWhile<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Iterable<A>> {
 
     private TakeWhile() {
     }
 
     @Override
-    public Iterable<A> apply(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public Iterable<A> apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return () -> new PredicatedTakingIterator<>(predicate, as.iterator());
     }
 
@@ -27,12 +27,12 @@ public static <A> TakeWhile<A> takeWhile() {
         return new TakeWhile<>();
     }
 
-    public static <A> MonadicFunction<Iterable<A>, Iterable<A>> takeWhile(
-            MonadicFunction<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> takeWhile(
+            Fn1<? super A, Boolean> predicate) {
         return TakeWhile.<A>takeWhile().apply(predicate);
     }
 
-    public static <A> Iterable<A> takeWhile(MonadicFunction<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Iterable<A> takeWhile(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
         return TakeWhile.<A>takeWhile(predicate).apply(as);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2.java
similarity index 70%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2.java
index 21a015ee8..aed51e164 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2.java
@@ -1,8 +1,8 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 
@@ -13,7 +13,7 @@
  * @param <B> The type of the second value; also the second slot type of returned Tuple2
  * @see com.jnape.palatable.lambda.adt.hlist.Tuple2
  */
-public final class Tupler2<A, B> implements DyadicFunction<A, B, Tuple2<A, B>> {
+public final class Tupler2<A, B> implements Fn2<A, B, Tuple2<A, B>> {
 
     private Tupler2() {
     }
@@ -27,7 +27,7 @@ public static <A, B> Tupler2<A, B> tupler() {
         return new Tupler2<>();
     }
 
-    public static <A, B> MonadicFunction<B, Tuple2<A, B>> tupler(A a) {
+    public static <A, B> Fn1<B, Tuple2<A, B>> tupler(A a) {
         return Tupler2.<A, B>tupler().apply(a);
     }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Unfoldr.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
similarity index 61%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Unfoldr.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
index 0a1e311a8..6befaf292 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Unfoldr.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
@@ -1,8 +1,8 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.UnfoldingIterator;
 
 import java.util.Optional;
@@ -28,25 +28,25 @@
  * @param <A> The output Iterable element type
  * @param <B> The unfolding function input type
  */
-public final class Unfoldr<A, B> implements DyadicFunction<MonadicFunction<B, Optional<Tuple2<A, B>>>, B, Iterable<A>> {
+public final class Unfoldr<A, B> implements Fn2<Fn1<B, Optional<Tuple2<A, B>>>, B, Iterable<A>> {
 
     private Unfoldr() {
     }
 
     @Override
-    public Iterable<A> apply(MonadicFunction<B, Optional<Tuple2<A, B>>> function, B b) {
-        return () -> new UnfoldingIterator<>(function, b);
+    public Iterable<A> apply(Fn1<B, Optional<Tuple2<A, B>>> fn, B b) {
+        return () -> new UnfoldingIterator<>(fn, b);
     }
 
     public static <A, B> Unfoldr<A, B> unfoldr() {
         return new Unfoldr<>();
     }
 
-    public static <A, B> MonadicFunction<B, Iterable<A>> unfoldr(MonadicFunction<B, Optional<Tuple2<A, B>>> function) {
-        return Unfoldr.<A, B>unfoldr().apply(function);
+    public static <A, B> Fn1<B, Iterable<A>> unfoldr(Fn1<B, Optional<Tuple2<A, B>>> fn) {
+        return Unfoldr.<A, B>unfoldr().apply(fn);
     }
 
-    public static <A, B> Iterable<A> unfoldr(MonadicFunction<B, Optional<Tuple2<A, B>>> function, B b) {
-        return unfoldr(function).apply(b);
+    public static <A, B> Iterable<A> unfoldr(Fn1<B, Optional<Tuple2<A, B>>> fn, B b) {
+        return unfoldr(fn).apply(b);
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Zip.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java
similarity index 61%
rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Zip.java
rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java
index e985fd7f9..1cc8838ca 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Zip.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java
@@ -1,11 +1,11 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Tupler2.tupler;
-import static com.jnape.palatable.lambda.functions.builtin.triadic.ZipWith.zipWith;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Tupler2.tupler;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith.zipWith;
 
 /**
  * Zip together two <code>Iterable</code>s into a single <code>Iterable</code> of <code>Tuple2&lt;A, B&gt;</code>. If
@@ -14,9 +14,9 @@
  *
  * @param <A> The first input Iterable element type, and the type of the first tuple slot in the output Iterable
  * @param <B> The second input Iterable element type, and the type of the second tuple slot in the output Iterable
- * @see com.jnape.palatable.lambda.functions.builtin.triadic.ZipWith
+ * @see com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith
  */
-public final class Zip<A, B> implements DyadicFunction<Iterable<A>, Iterable<B>, Iterable<Tuple2<A, B>>> {
+public final class Zip<A, B> implements Fn2<Iterable<A>, Iterable<B>, Iterable<Tuple2<A, B>>> {
 
     private Zip() {
     }
@@ -30,7 +30,7 @@ public static <A, B> Zip<A, B> zip() {
         return new Zip<>();
     }
 
-    public static <A, B> MonadicFunction<Iterable<B>, Iterable<Tuple2<A, B>>> zip(Iterable<A> as) {
+    public static <A, B> Fn1<Iterable<B>, Iterable<Tuple2<A, B>>> zip(Iterable<A> as) {
         return Zip.<A, B>zip().apply(as);
     }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeft.java
new file mode 100644
index 000000000..97f5a658c
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeft.java
@@ -0,0 +1,49 @@
+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;
+
+/**
+ * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link Fn2}&lt;B, A,
+ * B&gt;</code>, iteratively accumulate over the <code>Iterable</code>, ultimately returning a final <code>B</code>
+ * value. If the <code>Iterable</code> is empty, just return the starting <code>B</code> value. Note that, as the name
+ * implies, this function accumulates from left to right, such that <code>foldLeft(f, 0, asList(1, 2, 3, 4, 5))</code>
+ * is evaluated as <code>f(f(f(f(f(0, 1), 2), 3), 4), 5)</code>.
+ * <p>
+ * For more information, read about <a href="https://en.wikipedia.org/wiki/Catamorphism"
+ * target="_top">Catamorphisms</a>.
+ *
+ * @param <A> The Iterable element type
+ * @param <B> The accumulation type
+ * @see FoldRight
+ */
+public final class FoldLeft<A, B> implements Fn3<Fn2<? super B, ? super A, ? extends B>, B, Iterable<A>, B> {
+
+    private FoldLeft() {
+    }
+
+    @Override
+    public B apply(Fn2<? super B, ? super A, ? extends B> fn, B acc, Iterable<A> as) {
+        B accumulation = acc;
+        for (A a : as)
+            accumulation = fn.apply(accumulation, a);
+        return accumulation;
+    }
+
+    public static <A, B> FoldLeft<A, B> foldLeft() {
+        return new FoldLeft<>();
+    }
+
+    public static <A, B> Fn2<B, Iterable<A>, B> foldLeft(Fn2<? super B, ? super A, ? extends B> fn) {
+        return FoldLeft.<A, B>foldLeft().apply(fn);
+    }
+
+    public static <A, B> Fn1<Iterable<A>, B> foldLeft(Fn2<? super B, ? super A, ? extends B> fn, B acc) {
+        return FoldLeft.<A, B>foldLeft(fn).apply(acc);
+    }
+
+    public static <A, B> B foldLeft(Fn2<? super B, ? super A, ? extends B> fn, B acc, Iterable<A> as) {
+        return FoldLeft.<A, B>foldLeft(fn, acc).apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRight.java
new file mode 100644
index 000000000..c5717a50d
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRight.java
@@ -0,0 +1,49 @@
+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 static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft;
+
+/**
+ * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link Fn2}&lt;A, B,
+ * B&gt;</code>, iteratively accumulate over the <code>Iterable</code>, ultimately returning a final <code>B</code>
+ * value. If the <code>Iterable</code> is empty, just return the starting <code>B</code> value. This function is the
+ * iterative inverse of {@link FoldLeft}, such that <code>foldRight(f, 0, asList(1, 2, 3, 4, 5))</code> is evaluated as
+ * <code>f(f(f(f(f(0, 5), 4), 3), 2), 1)</code>.
+ * <p>
+ * For more information, read about <a href="https://en.wikipedia.org/wiki/Catamorphism"
+ * target="_top">Catamorphisms</a>.
+ *
+ * @param <A> The Iterable element type
+ * @param <B> The accumulation type
+ * @see FoldLeft
+ */
+public final class FoldRight<A, B> implements Fn3<Fn2<? super A, ? super B, ? extends B>, B, Iterable<A>, B> {
+
+    private FoldRight() {
+    }
+
+    @Override
+    public B apply(Fn2<? super A, ? super B, ? extends B> fn, B acc, Iterable<A> as) {
+        return foldLeft(fn.flip(), acc, reverse(as));
+    }
+
+    public static <A, B> FoldRight<A, B> foldRight() {
+        return new FoldRight<>();
+    }
+
+    public static <A, B> Fn2<B, Iterable<A>, B> foldRight(Fn2<? super A, ? super B, ? extends B> fn) {
+        return FoldRight.<A, B>foldRight().apply(fn);
+    }
+
+    public static <A, B> Fn1<Iterable<A>, B> foldRight(Fn2<? super A, ? super B, ? extends B> fn, B acc) {
+        return FoldRight.<A, B>foldRight(fn).apply(acc);
+    }
+
+    public static <A, B> B foldRight(Fn2<? super A, ? super B, ? extends B> fn, B acc, Iterable<A> as) {
+        return FoldRight.<A, B>foldRight(fn, acc).apply(as);
+    }
+}
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
new file mode 100644
index 000000000..84a513223
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java
@@ -0,0 +1,44 @@
+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.iterators.ScanningIterator;
+
+/**
+ * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link Fn2}&lt;B, A,
+ * B&gt;</code>, iteratively accumulate over the <code>Iterable</code>, collecting each function application result,
+ * finally returning an <code>Iterable</code> of all the results. Note that, as the name implies, this function
+ * accumulates from left to right, such that <code>scanLeft(f, 0, asList(1,2,3,4,5))</code> is evaluated as 0, f(0, 1),
+ * f(f(0, 1), 2), f(f(f(0, 1), 2), 3), f(f(f(f(0, 1), 2), 3), 4), f(f(f(f(f(0, 1), 2), 3), 4), 5).
+ *
+ * @param <A> The Iterable element type
+ * @param <B> The accumulation type
+ * @see FoldLeft
+ */
+public final class ScanLeft<A, B> implements Fn3<Fn2<? super B, ? super A, ? extends B>, B, Iterable<A>, Iterable<B>> {
+
+    private ScanLeft() {
+    }
+
+    @Override
+    public Iterable<B> apply(Fn2<? super B, ? super A, ? extends B> fn, B b, Iterable<A> as) {
+        return () -> new ScanningIterator<>(fn, b, as.iterator());
+    }
+
+    public static <A, B> ScanLeft<A, B> scanLeft() {
+        return new ScanLeft<>();
+    }
+
+    public static <A, B> Fn2<B, Iterable<A>, Iterable<B>> scanLeft(Fn2<? super B, ? super A, ? extends B> fn) {
+        return ScanLeft.<A, B>scanLeft().apply(fn);
+    }
+
+    public static <A, B> Fn1<Iterable<A>, Iterable<B>> scanLeft(Fn2<? super B, ? super A, ? extends B> fn, B b) {
+        return ScanLeft.<A, B>scanLeft(fn).apply(b);
+    }
+
+    public static <A, B> Iterable<B> scanLeft(Fn2<? super B, ? super A, ? extends B> fn, B b, Iterable<A> as) {
+        return ScanLeft.<A, B>scanLeft(fn, b).apply(as);
+    }
+}
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
new file mode 100644
index 000000000..eb5ea480b
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java
@@ -0,0 +1,46 @@
+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.iterators.ZippingIterator;
+
+/**
+ * Zip together two <code>Iterable</code>s by applying a zipping function to the successive elements of each
+ * <code>Iterable</code> until one of them runs out of elements. Returns an <code>Iterable</code> containing the
+ * results.
+ *
+ * @param <A> The first input Iterable element type
+ * @param <B> The second input Iterable element type
+ * @param <C> The output Iterable element type
+ * @see com.jnape.palatable.lambda.functions.builtin.fn2.Zip
+ */
+public final class ZipWith<A, B, C> implements Fn3<Fn2<? super A, ? super B, ? extends C>, Iterable<A>, Iterable<B>, Iterable<C>> {
+
+    private ZipWith() {
+    }
+
+    @Override
+    public Iterable<C> apply(Fn2<? super A, ? super B, ? extends C> zipper, Iterable<A> as, Iterable<B> bs) {
+        return () -> new ZippingIterator<>(zipper, as.iterator(), bs.iterator());
+    }
+
+    public static <A, B, C> ZipWith<A, B, C> zipWith() {
+        return new ZipWith<>();
+    }
+
+    public static <A, B, C> Fn2<Iterable<A>, Iterable<B>, Iterable<C>> zipWith(
+            Fn2<? super A, ? super B, ? extends C> zipper) {
+        return ZipWith.<A, B, C>zipWith().apply(zipper);
+    }
+
+    public static <A, B, C> Fn1<Iterable<B>, Iterable<C>> zipWith(Fn2<? super A, ? super B, ? extends C> zipper,
+                                                                  Iterable<A> as) {
+        return ZipWith.<A, B, C>zipWith(zipper).apply(as);
+    }
+
+    public static <A, B, C> Iterable<C> zipWith(Fn2<? super A, ? super B, ? extends C> zipper, Iterable<A> as,
+                                                Iterable<B> bs) {
+        return ZipWith.<A, B, C>zipWith(zipper, as).apply(bs);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java
deleted file mode 100644
index 104bbf416..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
-
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-
-/**
- * Given a value, produce a function that returns that value, regardless of input.
- *
- * @param <A> The input type of the resulting function
- * @param <B> The output type of the resulting function
- */
-public final class Constantly<A, B> implements MonadicFunction<A, B> {
-
-    private final B b;
-
-    public Constantly(B b) {
-        this.b = b;
-    }
-
-    @Override
-    public B apply(A a) {
-        return b;
-    }
-
-    public static <A, B> MonadicFunction<A, B> constantly(B b) {
-        return new Constantly<>(b);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java
deleted file mode 100644
index 1f454e380..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
-
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-
-/**
- * The identity function.
- *
- * @param <A> The input/output type
- */
-public final class Identity<A> implements MonadicFunction<A, A> {
-
-    private static final Identity IDENTITY = new Identity();
-
-    @Override
-    public A apply(A a) {
-        return a;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <A> Identity<A> id() {
-        return (Identity<A>) IDENTITY;
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java
deleted file mode 100644
index d6c6810d1..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-import com.jnape.palatable.lambda.functions.TriadicFunction;
-
-/**
- * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link
- * DyadicFunction}&lt;B, A, B&gt;</code>, iteratively accumulate over the <code>Iterable</code>, ultimately returning a
- * final <code>B</code> value. If the <code>Iterable</code> is empty, just return the starting <code>B</code> value.
- * Note that, as the name implies, this function accumulates from left to right, such that <code>foldLeft(f, 0,
- * asList(1, 2, 3, 4, 5))</code> is evaluated as <code>f(f(f(f(f(0, 1), 2), 3), 4), 5)</code>.
- * <p>
- * For more information, read about <a href="https://en.wikipedia.org/wiki/Catamorphism"
- * target="_top">Catamorphisms</a>.
- *
- * @param <A> The Iterable element type
- * @param <B> The accumulation type
- * @see FoldRight
- */
-public final class FoldLeft<A, B> implements TriadicFunction<DyadicFunction<? super B, ? super A, ? extends B>, B, Iterable<A>, B> {
-
-    @Override
-    public B apply(DyadicFunction<? super B, ? super A, ? extends B> function, B initialAccumulation,
-                   Iterable<A> as) {
-        B accumulation = initialAccumulation;
-        for (A a : as)
-            accumulation = function.apply(accumulation, a);
-        return accumulation;
-    }
-
-    public static <A, B> FoldLeft<A, B> foldLeft() {
-        return new FoldLeft<>();
-    }
-
-    public static <A, B> DyadicFunction<B, Iterable<A>, B> foldLeft(
-            DyadicFunction<? super B, ? super A, ? extends B> function) {
-        return FoldLeft.<A, B>foldLeft().apply(function);
-    }
-
-    public static <A, B> MonadicFunction<Iterable<A>, B> foldLeft(
-            DyadicFunction<? super B, ? super A, ? extends B> function, B initialAccumulation) {
-        return FoldLeft.<A, B>foldLeft(function).apply(initialAccumulation);
-    }
-
-    public static <A, B> B foldLeft(DyadicFunction<? super B, ? super A, ? extends B> function, B initialAccumulation,
-                                    Iterable<A> as) {
-        return FoldLeft.<A, B>foldLeft(function, initialAccumulation).apply(as);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java
deleted file mode 100644
index 657f740ea..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-import com.jnape.palatable.lambda.functions.TriadicFunction;
-
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Reverse.reverse;
-import static com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft.foldLeft;
-
-/**
- * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link
- * DyadicFunction}&lt;A, B, B&gt;</code>, iteratively accumulate over the <code>Iterable</code>, ultimately returning a
- * final <code>B</code> value. If the <code>Iterable</code> is empty, just return the starting <code>B</code> value.
- * This function is the iterative inverse of {@link FoldLeft}, such that <code>foldRight(f, 0, asList(1, 2, 3, 4,
- * 5))</code> is evaluated as <code>f(f(f(f(f(0, 5), 4), 3), 2), 1)</code>.
- * <p>
- * For more information, read about <a href="https://en.wikipedia.org/wiki/Catamorphism"
- * target="_top">Catamorphisms</a>.
- *
- * @param <A> The Iterable element type
- * @param <B> The accumulation type
- * @see FoldLeft
- */
-public final class FoldRight<A, B> implements TriadicFunction<DyadicFunction<? super A, ? super B, ? extends B>, B, Iterable<A>, B> {
-
-    @Override
-    public B apply(DyadicFunction<? super A, ? super B, ? extends B> function, B initialAccumulation, Iterable<A> as) {
-        return foldLeft(function.flip(), initialAccumulation, reverse(as));
-    }
-
-    public static <A, B> FoldRight<A, B> foldRight() {
-        return new FoldRight<>();
-    }
-
-    public static <A, B> DyadicFunction<B, Iterable<A>, B> foldRight(
-            DyadicFunction<? super A, ? super B, ? extends B> function) {
-        return FoldRight.<A, B>foldRight().apply(function);
-    }
-
-    public static <A, B> MonadicFunction<Iterable<A>, B> foldRight(
-            DyadicFunction<? super A, ? super B, ? extends B> function, B initialAccumulation) {
-        return FoldRight.<A, B>foldRight(function).apply(initialAccumulation);
-    }
-
-    public static <A, B> B foldRight(DyadicFunction<? super A, ? super B, ? extends B> function, B initialAccumulation,
-                                     Iterable<A> as) {
-        return FoldRight.<A, B>foldRight(function, initialAccumulation).apply(as);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java
deleted file mode 100644
index d00dd9fa9..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-import com.jnape.palatable.lambda.functions.TriadicFunction;
-import com.jnape.palatable.lambda.iterators.ScanningIterator;
-
-import static java.util.Arrays.asList;
-
-/**
- * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link
- * DyadicFunction}&lt;B, A, B&gt;</code>, iteratively accumulate over the <code>Iterable</code>, collecting each
- * function application result, finally returning an <code>Iterable</code> of all the results. Note that, as the name
- * implies, this function accumulates from left to right, such that <code>scanLeft(f, 0, asList(1,2,3,4,5))</code> is
- * evaluated as 0, f(0, 1), f(f(0, 1), 2), f(f(f(0, 1), 2), 3), f(f(f(f(0, 1), 2), 3), 4), f(f(f(f(f(0, 1), 2), 3), 4),
- * 5).
- *
- * @param <A> The Iterable element type
- * @param <B> The accumulation type
- * @see FoldLeft
- */
-public final class ScanLeft<A, B> implements TriadicFunction<DyadicFunction<? super B, ? super A, ? extends B>, B, Iterable<A>, Iterable<B>> {
-
-    @Override
-    public Iterable<B> apply(DyadicFunction<? super B, ? super A, ? extends B> fn, B b, Iterable<A> as) {
-        return () -> new ScanningIterator<>(fn, b, as.iterator());
-    }
-
-    public static <A, B> ScanLeft<A, B> scanLeft() {
-        return new ScanLeft<>();
-    }
-
-    public static <A, B> DyadicFunction<B, Iterable<A>, Iterable<B>> scanLeft(
-            DyadicFunction<? super B, ? super A, ? extends B> fn) {
-        return ScanLeft.<A, B>scanLeft().apply(fn);
-    }
-
-    public static <A, B> MonadicFunction<Iterable<A>, Iterable<B>> scanLeft(
-            DyadicFunction<? super B, ? super A, ? extends B> fn, B b) {
-        return ScanLeft.<A, B>scanLeft(fn).apply(b);
-    }
-
-    public static <A, B> Iterable<B> scanLeft(DyadicFunction<? super B, ? super A, ? extends B> fn, B b,
-                                              Iterable<A> as) {
-        return ScanLeft.<A, B>scanLeft(fn, b).apply(as);
-    }
-
-    public static void main(String[] args) {
-        scanLeft((acc, x) -> "f(" + acc + ", " + x + ")", "0", asList(1, 2, 3, 4, 5)).forEach(System.out::println);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java
deleted file mode 100644
index 817218f1e..000000000
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
-import com.jnape.palatable.lambda.functions.TriadicFunction;
-import com.jnape.palatable.lambda.iterators.ZippingIterator;
-
-/**
- * Zip together two <code>Iterable</code>s by applying a zipping function to the successive elements of each
- * <code>Iterable</code> until one of them runs out of elements. Returns an <code>Iterable</code> containing the
- * results.
- *
- * @param <A> The first input Iterable element type
- * @param <B> The second input Iterable element type
- * @param <C> The output Iterable element type
- * @see com.jnape.palatable.lambda.functions.builtin.dyadic.Zip
- */
-public final class ZipWith<A, B, C> implements TriadicFunction<DyadicFunction<? super A, ? super B, ? extends C>, Iterable<A>, Iterable<B>, Iterable<C>> {
-
-    @Override
-    public Iterable<C> apply(DyadicFunction<? super A, ? super B, ? extends C> zipper, Iterable<A> as, Iterable<B> bs) {
-        return () -> new ZippingIterator<>(zipper, as.iterator(), bs.iterator());
-    }
-
-    public static <A, B, C> ZipWith<A, B, C> zipWith() {
-        return new ZipWith<>();
-    }
-
-    public static <A, B, C> DyadicFunction<Iterable<A>, Iterable<B>, Iterable<C>> zipWith(
-            DyadicFunction<? super A, ? super B, ? extends C> zipper) {
-        return ZipWith.<A, B, C>zipWith().apply(zipper);
-    }
-
-    public static <A, B, C> MonadicFunction<Iterable<B>, Iterable<C>> zipWith(
-            DyadicFunction<? super A, ? super B, ? extends C> zipper, Iterable<A> as) {
-        return ZipWith.<A, B, C>zipWith(zipper).apply(as);
-    }
-
-    public static <A, B, C> Iterable<C> zipWith(DyadicFunction<? super A, ? super B, ? extends C> zipper,
-                                                Iterable<A> as, Iterable<B> bs) {
-        return ZipWith.<A, B, C>zipWith(zipper, as).apply(bs);
-    }
-}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java
index 5b3095972..f9c2037f4 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java
@@ -1,29 +1,77 @@
 package com.jnape.palatable.lambda.functions.specialized;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+
+import java.util.function.Function;
 
 /**
- * A specialized {@link MonadicFunction} that returns a <code>Boolean</code>.
+ * A specialized {@link Fn1} that returns a <code>Boolean</code>.
  *
  * @param <A> The argument type
  */
-public interface Predicate<A> extends MonadicFunction<A, Boolean>, java.util.function.Predicate<A> {
+public interface Predicate<A> extends Fn1<A, Boolean>, java.util.function.Predicate<A> {
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     default boolean test(A a) {
         return apply(a);
     }
 
+    /**
+     * Override of {@link Function#compose(Function)}, returning an instance of <code>Predicate</code> for
+     * compatibility. Right-to-left composition.
+     *
+     * @param before the function who's return value is this predicate's argument
+     * @param <Z>    the new argument type
+     * @return a new predicate of Z (the new argument type)
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    default <Z> Predicate<Z> compose(Function<? super Z, ? extends A> before) {
+        return Fn1.super.compose(before)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    default <Z> Predicate<Z> diMapL(Fn1<Z, A> fn) {
+        return Fn1.super.diMapL(fn)::apply;
+    }
+
+    /**
+     * Override of {@link java.util.function.Predicate#and(java.util.function.Predicate)}, returning an instance of
+     * <code>Predicate</code> for compatibility. Left-to-right composition.
+     *
+     * @param other the predicate to test if this one succeeds
+     * @return a predicate representing the conjunction of this predicate and other
+     */
     @Override
     default Predicate<A> and(java.util.function.Predicate<? super A> other) {
         return a -> apply(a) && other.test(a);
     }
 
+    /**
+     * Override of {@link java.util.function.Predicate#or(java.util.function.Predicate)}, returning an instance of
+     * <code>Predicate</code> for compatibility. Left-to-right composition.
+     *
+     * @param other the predicate to test if this one fails
+     * @return a predicate representing the disjunction of this predicate and other
+     */
     @Override
     default Predicate<A> or(java.util.function.Predicate<? super A> other) {
         return a -> apply(a) || other.test(a);
     }
 
+    /**
+     * Override of {@link java.util.function.Predicate#negate()}, returning an instance of <code>Predicate</code> for
+     * compatibility.
+     *
+     * @return the negation of this predicate
+     */
     @Override
     default Predicate<A> negate() {
         return a -> !apply(a);
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedMonadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
similarity index 53%
rename from src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedMonadicFunction.java
rename to src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
index c5013e4ad..15c17a796 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedMonadicFunction.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
@@ -1,19 +1,19 @@
 package com.jnape.palatable.lambda.functions.specialized.checked;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
 import static com.jnape.palatable.lambda.functions.specialized.checked.Runtime.throwChecked;
 
 /**
- * Specialized {@link MonadicFunction} that can throw checked exceptions.
+ * Specialized {@link Fn1} that can throw checked exceptions.
  *
  * @param <A> The input type
  * @param <B> The output type
  * @see CheckedSupplier
- * @see MonadicFunction
+ * @see Fn1
  */
 @FunctionalInterface
-public interface CheckedMonadicFunction<A, B> extends MonadicFunction<A, B> {
+public interface CheckedFn1<A, B> extends Fn1<A, B> {
 
     @Override
     default B apply(A a) {
@@ -24,5 +24,12 @@ default B apply(A a) {
         }
     }
 
+    /**
+     * A version of {@link Fn1} that can throw checked exceptions.
+     *
+     * @param a the argument
+     * @return the result of the function application
+     * @throws Exception any exception thrown by the function application
+     */
     B checkedApply(A a) throws Exception;
 }
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 4009538b1..b16b2d6f8 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
@@ -9,7 +9,7 @@
  *
  * @param <E> The exception type
  * @param <T> The return type
- * @see CheckedMonadicFunction
+ * @see CheckedFn1
  */
 @FunctionalInterface
 public interface CheckedSupplier<E extends Exception, T> extends Supplier<T> {
@@ -23,5 +23,11 @@ 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
+     */
     T checkedGet() throws E;
 }
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 903aa463f..906c20a8c 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java
@@ -1,16 +1,16 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
- * A dually-parametric <code>Functor</code> that maps covariantly over both parameters.
+ * A dually-parametric functor that maps covariantly over both parameters.
  * <p>
  * For more information, read about <a href="https://en.wikipedia.org/wiki/Bifunctor" target="_top">Bifunctors</a>.
  *
- * @param <A> The type of the first parameter
- * @param <B> The type of the second parameter
+ * @param <A> The type of the left parameter
+ * @param <B> The type of the right parameter
  * @see Functor
  * @see Profunctor
  * @see com.jnape.palatable.lambda.adt.hlist.Tuple2
@@ -18,14 +18,38 @@
 @FunctionalInterface
 public interface Bifunctor<A, B> {
 
-    default <C> Bifunctor<C, B> biMapL(MonadicFunction<? super A, ? extends C> fn) {
+    /**
+     * Covariantly map over the left parameter.
+     *
+     * @param fn  the mapping function
+     * @param <C> the new left parameter type
+     * @return a bifunctor over C (the new left parameter) and B (the same right parameter)
+     */
+    default <C> Bifunctor<C, B> biMapL(Fn1<? super A, ? extends C> fn) {
         return biMap(fn, id());
     }
 
-    default <C> Bifunctor<A, C> biMapR(MonadicFunction<? super B, ? extends C> fn) {
+    /**
+     * Covariantly map over the right parameter. For all bifunctors that are also functors, it should hold that
+     * <code>biMapR(f) == fmap(f)</code>.
+     *
+     * @param fn  the mapping function
+     * @param <C> the new right parameter type
+     * @return a bifunctor over A (the same left parameter) and C (the new right parameter)
+     */
+    default <C> Bifunctor<A, C> biMapR(Fn1<? super B, ? extends C> fn) {
         return biMap(id(), fn);
     }
 
-    <C, D> Bifunctor<C, D> biMap(MonadicFunction<? super A, ? extends C> lFn,
-                                 MonadicFunction<? super B, ? extends D> rFn);
+    /**
+     * Dually map covariantly over both the left and right parameters. This is isomorphic to
+     * <code>biMapL(lFn).biMapR(rFn)</code>.
+     *
+     * @param lFn the left parameter mapping function
+     * @param rFn the right parameter mapping function
+     * @param <C> the new left parameter type
+     * @param <D> the new right parameter type
+     * @return a bifunctor over Z (the new left parameter type) and C (the new right parameter type)
+     */
+    <C, D> Bifunctor<C, D> biMap(Fn1<? super A, ? extends C> lFn, Fn1<? super B, ? extends D> rFn);
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Functor.java b/src/main/java/com/jnape/palatable/lambda/functor/Functor.java
index 3f7388096..2d600d433 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Functor.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Functor.java
@@ -1,6 +1,6 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
 /**
  * An interface for the generic covariant functorial operation <code>map</code> over some parameter <code>A</code>.
@@ -12,12 +12,20 @@
  * @param <A> The type of the parameter
  * @see Bifunctor
  * @see Profunctor
- * @see MonadicFunction
+ * @see Fn1
  * @see com.jnape.palatable.lambda.adt.hlist.Tuple2
  * @see com.jnape.palatable.lambda.adt.Either
  */
 @FunctionalInterface
 public interface Functor<A> {
 
-    <B> Functor<B> fmap(MonadicFunction<? super A, ? extends B> fn);
+    /**
+     * Covariantly transmute this functor's parameter using the given mapping function. Generally this method is
+     * specialized to return an instance of the class implementing Functor.
+     *
+     * @param fn  the mapping function
+     * @param <B> the new parameter type
+     * @return a functor over B (the new parameter type)
+     */
+    <B> Functor<B> fmap(Fn1<? super A, ? extends B> fn);
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java
index edc79ab45..aae917e55 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java
@@ -1,32 +1,56 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
- * A dually-parametric <code>Functor</code> that maps contravariantly over the first parameter and covariantly over the
- * second.
+ * A dually-parametric functor that maps contravariantly over the left parameter and covariantly over the
+ * right.
  * <p>
  * For more information, read about <a href="https://en.wikipedia.org/wiki/Profunctor" target="_top">Profunctors</a>.
  *
- * @param <A> The type of the first parameter
- * @param <B> The type of the second parameter
+ * @param <A> The type of the left parameter
+ * @param <B> The type of the right parameter
  * @see Functor
  * @see Bifunctor
- * @see com.jnape.palatable.lambda.functions.DyadicFunction
+ * @see Fn1
  */
 @FunctionalInterface
 public interface Profunctor<A, B> {
 
-    default <C> Profunctor<C, B> diMapL(MonadicFunction<? super C, ? extends A> fn) {
+    /**
+     * Contravariantly map over the left parameter.
+     *
+     * @param fn  the mapping function
+     * @param <Z> the new left parameter type
+     * @return a profunctor over Z (the new left parameter type) and C (the same right parameter type)
+     */
+    default <Z> Profunctor<Z, B> diMapL(Fn1<Z, A> fn) {
         return diMap(fn, id());
     }
 
-    default <C> Profunctor<A, C> diMapR(MonadicFunction<? super B, ? extends C> fn) {
+    /**
+     * Covariantly map over the right parameter. For all profunctors that are also functors, it should hold that
+     * <code>diMapR(f) == fmap(f)</code>.
+     *
+     * @param fn  the mapping function
+     * @param <C> the new right parameter type
+     * @return a profunctor over A (the same left parameter type) and C (the new right parameter type)
+     */
+    default <C> Profunctor<A, C> diMapR(Fn1<B, C> fn) {
         return diMap(id(), fn);
     }
 
-    <C, D> Profunctor<C, D> diMap(MonadicFunction<? super C, ? extends A> f1,
-                                  MonadicFunction<? super B, ? extends D> f2);
+    /**
+     * Dually map contravariantly over the left parameter and covariantly over the right parameter. This is isomorphic
+     * to <code>diMapL(lFn).diMapR(rFn)</code>.
+     *
+     * @param lFn the left parameter mapping function
+     * @param rFn the right parameter mapping function
+     * @param <Z> the new left parameter type
+     * @param <C> the new right parameter type
+     * @return a profunctor over Z (the new left parameter type) and C (the new right parameter tyep)
+     */
+    <Z, C> Profunctor<Z, C> diMap(Fn1<Z, A> lFn, Fn1<B, C> rFn);
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java
index c3c8cd9f8..093868e5e 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java
@@ -1,16 +1,16 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 public class FilteringIterator<A> extends ImmutableIterator<A> {
 
-    private final MonadicFunction<? super A, Boolean> predicate;
-    private final RewindableIterator<A>               rewindableIterator;
+    private final Fn1<? super A, Boolean> predicate;
+    private final RewindableIterator<A>   rewindableIterator;
 
-    public FilteringIterator(MonadicFunction<? super A, Boolean> predicate, Iterator<A> iterator) {
+    public FilteringIterator(Fn1<? super A, Boolean> predicate, Iterator<A> iterator) {
         this.predicate = predicate;
         rewindableIterator = new RewindableIterator<>(iterator);
     }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java
index 8a93fc2bd..f950ee386 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java
@@ -1,15 +1,15 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
 import java.util.Iterator;
 
 public class MappingIterator<A, B> extends ImmutableIterator<B> {
 
-    private final MonadicFunction<? super A, ? extends B> function;
-    private final Iterator<A>                             iterator;
+    private final Fn1<? super A, ? extends B> function;
+    private final Iterator<A>                 iterator;
 
-    public MappingIterator(MonadicFunction<? super A, ? extends B> function, Iterator<A> iterator) {
+    public MappingIterator(Fn1<? super A, ? extends B> function, Iterator<A> iterator) {
         this.function = function;
         this.iterator = iterator;
     }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java
index 15c6bf944..02deacbf8 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java
@@ -1,16 +1,16 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 public class PredicatedDroppingIterator<A> extends ImmutableIterator<A> {
-    private final MonadicFunction<? super A, Boolean> predicate;
-    private final RewindableIterator<A>               rewindableIterator;
-    private       boolean                             finishedDropping;
+    private final Fn1<? super A, Boolean> predicate;
+    private final RewindableIterator<A>   rewindableIterator;
+    private       boolean                 finishedDropping;
 
-    public PredicatedDroppingIterator(MonadicFunction<? super A, Boolean> predicate, Iterator<A> asIterator) {
+    public PredicatedDroppingIterator(Fn1<? super A, Boolean> predicate, Iterator<A> asIterator) {
         this.predicate = predicate;
         rewindableIterator = new RewindableIterator<>(asIterator);
         finishedDropping = false;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java
index eb9bc32a8..3fbcd5e17 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java
@@ -1,16 +1,16 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 public class PredicatedTakingIterator<A> extends ImmutableIterator<A> {
-    private final MonadicFunction<? super A, Boolean> predicate;
-    private final RewindableIterator<A>               rewindableIterator;
-    private       boolean                             stillTaking;
+    private final Fn1<? super A, Boolean> predicate;
+    private final RewindableIterator<A>   rewindableIterator;
+    private       boolean                 stillTaking;
 
-    public PredicatedTakingIterator(MonadicFunction<? super A, Boolean> predicate,
+    public PredicatedTakingIterator(Fn1<? super A, Boolean> predicate,
                                     Iterator<A> asIterator) {
         this.predicate = predicate;
         rewindableIterator = new RewindableIterator<>(asIterator);
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java
index 67529fbac..99f96cb6a 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java
@@ -8,6 +8,7 @@ public class RewindableIterator<A> extends ImmutableIterator<A> {
     private final Iterator<A> asIterator;
     private final Cache<A>    cache;
     private       boolean     rewound;
+
     public RewindableIterator(Iterator<A> asIterator) {
         this.asIterator = asIterator;
         cache = new Cache<>();
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java
index 085ba592c..56e693629 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java
@@ -1,17 +1,17 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
+import com.jnape.palatable.lambda.functions.Fn2;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 public final class ScanningIterator<A, B> extends ImmutableIterator<B> {
 
-    private final DyadicFunction<? super B, ? super A, ? extends B> scanner;
-    private final Iterator<A>                                       asIterator;
-    private       B                                                 b;
+    private final Fn2<? super B, ? super A, ? extends B> scanner;
+    private final Iterator<A>                            asIterator;
+    private       B                                      b;
 
-    public ScanningIterator(DyadicFunction<? super B, ? super A, ? extends B> scanner, B b,
+    public ScanningIterator(Fn2<? super B, ? super A, ? extends B> scanner, B b,
                             Iterator<A> asIterator) {
         this.scanner = scanner;
         this.b = b;
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java
index 7a5ac3585..896ca19dd 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java
@@ -1,16 +1,16 @@
 package com.jnape.palatable.lambda.iterators;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 
 import java.util.NoSuchElementException;
 import java.util.Optional;
 
 public class UnfoldingIterator<A, B> extends ImmutableIterator<A> {
-    private final MonadicFunction<B, Optional<Tuple2<A, B>>> function;
-    private       Optional<Tuple2<A, B>>                     optionalAcc;
+    private final Fn1<B, Optional<Tuple2<A, B>>> function;
+    private       Optional<Tuple2<A, B>>         optionalAcc;
 
-    public UnfoldingIterator(MonadicFunction<B, Optional<Tuple2<A, B>>> function, B b) {
+    public UnfoldingIterator(Fn1<B, Optional<Tuple2<A, B>>> function, B b) {
         this.function = function;
         optionalAcc = function.apply(b);
     }
diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java
index f8a0dc0e5..16d05c146 100644
--- a/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java
+++ b/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java
@@ -1,15 +1,15 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
+import com.jnape.palatable.lambda.functions.Fn2;
 
 import java.util.Iterator;
 
 public class ZippingIterator<C, A, B> extends ImmutableIterator<C> {
-    private final DyadicFunction<? super A, ? super B, ? extends C> zipper;
-    private final Iterator<A>                                       asIterator;
-    private final Iterator<B>                                       bsIterator;
+    private final Fn2<? super A, ? super B, ? extends C> zipper;
+    private final Iterator<A>                            asIterator;
+    private final Iterator<B>                            bsIterator;
 
-    public ZippingIterator(DyadicFunction<? super A, ? super B, ? extends C> zipper, Iterator<A> asIterator,
+    public ZippingIterator(Fn2<? super A, ? super B, ? extends C> zipper, Iterator<A> asIterator,
                            Iterator<B> bsIterator) {
         this.asIterator = asIterator;
         this.bsIterator = bsIterator;
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 964e5ddfa..21cd82655 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
@@ -1,6 +1,6 @@
 package com.jnape.palatable.lambda.adt;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
+import com.jnape.palatable.lambda.functions.Fn2;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -98,8 +98,8 @@ public void mergeDuallyLiftsAndCombinesBiasingLeft() {
         Either<String, Integer> left2 = left("bar");
         Either<String, Integer> right2 = right(2);
 
-        DyadicFunction<String, String, String> concat = String::concat;
-        DyadicFunction<Integer, Integer, Integer> add = (r1, r2) -> r1 + r2;
+        Fn2<String, String, String> concat = String::concat;
+        Fn2<Integer, Integer, Integer> add = (r1, r2) -> r1 + r2;
 
         assertThat(left1.merge(concat, add, left2), is(left("foobar")));
         assertThat(left1.merge(concat, add, right2), is(left1));
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java
index 425fb9a02..6be65b6dc 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java
@@ -4,7 +4,7 @@
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.cons;
 import static com.jnape.palatable.lambda.adt.hlist.HList.nil;
-import static com.jnape.palatable.lambda.adt.hlist.HList.singleton;
+import static com.jnape.palatable.lambda.adt.hlist.HList.singletonHList;
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -29,7 +29,7 @@ public void tail() {
     @Test
     public void convenienceStaticFactoryMethods() {
         assertEquals(nil().cons(1), cons(1, nil()));
-        assertEquals(nil().cons(1), singleton(1));
+        assertEquals(nil().cons(1), singletonHList(1));
         assertEquals(nil().cons('2').cons(1), tuple(1, '2'));
         assertEquals(nil().cons("3").cons('2').cons(1), tuple(1, '2', "3"));
         assertEquals(nil().cons(4.0).cons("3").cons('2').cons(1), tuple(1, '2', "3", 4.0));
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonHListTest.java
similarity index 50%
rename from src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonTest.java
rename to src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonHListTest.java
index 3b062d372..18bc68a05 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonHListTest.java
@@ -6,32 +6,32 @@
 import static com.jnape.palatable.lambda.adt.hlist.HList.nil;
 import static org.junit.Assert.assertEquals;
 
-public class SingletonTest {
+public class SingletonHListTest {
 
-    private Singleton<Integer> singleton;
+    private SingletonHList<Integer> singletonHList;
 
     @Before
     public void setUp() {
-        singleton = new Singleton<>(1);
+        singletonHList = new SingletonHList<>(1);
     }
 
     @Test
     public void head() {
-        assertEquals((Integer) 1, singleton.head());
+        assertEquals((Integer) 1, singletonHList.head());
     }
 
     @Test
     public void tail() {
-        assertEquals(nil(), singleton.tail());
+        assertEquals(nil(), singletonHList.tail());
     }
 
     @Test
     public void cons() {
-        assertEquals(new Tuple2<>("0", singleton), singleton.cons("0"));
+        assertEquals(new Tuple2<>("0", singletonHList), singletonHList.cons("0"));
     }
 
     @Test
     public void functorProperties() {
-        assertEquals(new Singleton<>("1"), singleton.fmap(Object::toString));
+        assertEquals(new SingletonHList<>("1"), singletonHList.fmap(Object::toString));
     }
 }
\ 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 d74518bba..0719bd5f2 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
@@ -6,8 +6,13 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import static com.jnape.palatable.lambda.adt.hlist.HList.singletonHList;
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class Tuple2Test {
 
@@ -15,7 +20,7 @@ public class Tuple2Test {
 
     @Before
     public void setUp() throws Exception {
-        tuple2 = new Tuple2<>(1, new Singleton<>(2));
+        tuple2 = new Tuple2<>(1, new SingletonHList<>(2));
     }
 
     @Test
@@ -25,7 +30,7 @@ public void head() {
 
     @Test
     public void tail() {
-        assertEquals(new Singleton<>(2), tuple2.tail());
+        assertEquals(new SingletonHList<>(2), tuple2.tail());
     }
 
     @Test
@@ -39,14 +44,25 @@ public void accessors() {
         assertEquals((Integer) 2, tuple2._2());
     }
 
+    @Test
+    public void randomAccess() {
+        SingletonHList<String> spiedTail = spy(singletonHList("second"));
+        Tuple2<String, String> tuple2 = new Tuple2<>("first", spiedTail);
+
+        verify(spiedTail, only()).head();
+        tuple2._1();
+        tuple2._2();
+        verifyNoMoreInteractions(spiedTail);
+    }
+
     @Test
     public void functorProperties() {
-        assertEquals(new Tuple2<>(1, new Singleton<>("2")), tuple2.fmap(Object::toString));
+        assertEquals(new Tuple2<>(1, new SingletonHList<>("2")), tuple2.fmap(Object::toString));
     }
 
     @Test
     public void bifunctorProperties() {
-        assertEquals(new Tuple2<>("1", new Singleton<>("2")), tuple2.biMap(Object::toString, Object::toString));
+        assertEquals(new Tuple2<>("1", new SingletonHList<>("2")), tuple2.biMap(Object::toString, Object::toString));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java
index 9aa335811..a354a350c 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java
@@ -3,7 +3,12 @@
 import org.junit.Before;
 import org.junit.Test;
 
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class Tuple3Test {
 
@@ -11,7 +16,7 @@ public class Tuple3Test {
 
     @Before
     public void setUp() {
-        tuple3 = new Tuple3<>(1, new Tuple2<>("2", new Singleton<>('3')));
+        tuple3 = new Tuple3<>(1, new Tuple2<>("2", new SingletonHList<>('3')));
     }
 
     @Test
@@ -21,7 +26,7 @@ public void head() {
 
     @Test
     public void tail() {
-        assertEquals(new Tuple2<>("2", new Singleton<>('3')), tuple3.tail());
+        assertEquals(new Tuple2<>("2", new SingletonHList<>('3')), tuple3.tail());
     }
 
     @Test
@@ -36,13 +41,26 @@ public void accessors() {
         assertEquals((Character) '3', tuple3._3());
     }
 
+    @Test
+    public void randomAccess() {
+        Tuple2<String, String> spiedTail = spy(tuple("second", "third"));
+        Tuple3<String, String, String> tuple3 = new Tuple3<>("first", spiedTail);
+
+        verify(spiedTail, times(1))._1();
+        verify(spiedTail, times(1))._2();
+        tuple3._1();
+        tuple3._2();
+        tuple3._3();
+        verifyNoMoreInteractions(spiedTail);
+    }
+
     @Test
     public void functorProperties() {
-        assertEquals(new Tuple3<>(1, new Tuple2<>("2", new Singleton<>("3"))), tuple3.fmap(Object::toString));
+        assertEquals(new Tuple3<>(1, new Tuple2<>("2", new SingletonHList<>("3"))), tuple3.fmap(Object::toString));
     }
 
     @Test
     public void bifunctorProperties() {
-        assertEquals(new Tuple3<>(1, new Tuple2<>(2, new Singleton<>("3"))), tuple3.biMap(Integer::parseInt, Object::toString));
+        assertEquals(new Tuple3<>(1, new Tuple2<>(2, new SingletonHList<>("3"))), tuple3.biMap(Integer::parseInt, Object::toString));
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java
index 1213ec5a5..75567e324 100644
--- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java
@@ -3,7 +3,12 @@
 import org.junit.Before;
 import org.junit.Test;
 
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class Tuple4Test {
 
@@ -11,7 +16,7 @@ public class Tuple4Test {
 
     @Before
     public void setUp() {
-        tuple4 = new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new Singleton<>(false))));
+        tuple4 = new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new SingletonHList<>(false))));
     }
 
     @Test
@@ -21,7 +26,7 @@ public void head() {
 
     @Test
     public void tail() {
-        assertEquals(new Tuple3<>("2", new Tuple2<>('3', new Singleton<>(false))), tuple4.tail());
+        assertEquals(new Tuple3<>("2", new Tuple2<>('3', new SingletonHList<>(false))), tuple4.tail());
     }
 
     @Test
@@ -37,14 +42,29 @@ public void accessors() {
         assertEquals(false, tuple4._4());
     }
 
+    @Test
+    public void randomAccess() {
+        Tuple3<String, String, String> spiedTail = spy(tuple("second", "third", "fourth"));
+        Tuple4<String, String, String, String> tuple4 = new Tuple4<>("first", spiedTail);
+
+        verify(spiedTail, times(1))._1();
+        verify(spiedTail, times(1))._2();
+        verify(spiedTail, times(1))._3();
+        tuple4._1();
+        tuple4._2();
+        tuple4._3();
+        tuple4._4();
+        verifyNoMoreInteractions(spiedTail);
+    }
+
     @Test
     public void functorProperties() {
-        assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new Singleton<>(true)))), tuple4.fmap(x -> !x));
+        assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new SingletonHList<>(true)))), tuple4.fmap(x -> !x));
     }
 
     @Test
     public void bifunctorProperties() {
-        assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>("3", new Singleton<>(true)))),
+        assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>("3", new SingletonHList<>(true)))),
                      tuple4.biMap(Object::toString, x -> !x));
     }
 }
\ No newline at end of file
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 2745f3c47..febdb0007 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
@@ -4,7 +4,12 @@
 import org.junit.Before;
 import org.junit.Test;
 
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class Tuple5Test {
 
@@ -12,7 +17,7 @@ public class Tuple5Test {
 
     @Before
     public void setUp() {
-        tuple5 = new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new Singleton<>(5L)))));
+        tuple5 = new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new SingletonHList<>(5L)))));
     }
 
     @Test
@@ -22,7 +27,7 @@ public void head() {
 
     @Test
     public void tail() {
-        assertEquals(new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new Singleton<>(5L)))), tuple5.tail());
+        assertEquals(new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new SingletonHList<>(5L)))), tuple5.tail());
     }
 
     @Test
@@ -39,15 +44,32 @@ public void accessors() {
         assertEquals((Long) 5L, tuple5._5());
     }
 
+    @Test
+    public void randomAccess() {
+        Tuple4<String, String, String, String> spiedTail = spy(tuple("second", "third", "fourth", "fifth"));
+        Tuple5<String, String, String, String, String> tuple5 = new Tuple5<>("first", spiedTail);
+
+        verify(spiedTail, times(1))._1();
+        verify(spiedTail, times(1))._2();
+        verify(spiedTail, times(1))._3();
+        verify(spiedTail, times(1))._4();
+        tuple5._1();
+        tuple5._2();
+        tuple5._3();
+        tuple5._4();
+        tuple5._5();
+        verifyNoMoreInteractions(spiedTail);
+    }
+
     @Test
     public void functorProperties() {
-        assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new Singleton<>("5"))))),
+        assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new SingletonHList<>("5"))))),
                      tuple5.fmap(Object::toString));
     }
 
     @Test
     public void bifunctorProperties() {
-        assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(true, new Singleton<>("5"))))),
+        assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(true, new SingletonHList<>("5"))))),
                      tuple5.biMap(x -> !x, Object::toString));
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java
deleted file mode 100644
index 8ec963682..000000000
--- a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.jnape.palatable.lambda.functions;
-
-import org.junit.Test;
-
-import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-public class DyadicFunctionTest {
-
-    private static final DyadicFunction<String, Integer, Boolean> CHECK_LENGTH = (string,
-                                                                                  length) -> string.length() == length;
-
-    @Test
-    public void flipSwapsArguments() {
-        assertThat(CHECK_LENGTH.flip().apply(3, "foo"), is(true));
-    }
-
-    @Test
-    public void canBePartiallyApplied() {
-        assertThat(CHECK_LENGTH.apply("quux").apply(4), is(true));
-    }
-
-    @Test
-    public void uncurries() {
-        assertThat(CHECK_LENGTH.uncurry().apply(tuple("abc", 3)), is(true));
-    }
-
-    @Test
-    public void mapsContravariantlyOverSecondArgument() {
-        assertThat(CHECK_LENGTH.<String>diMapL(Integer::parseInt).apply("123").apply("3"), is(true));
-    }
-
-    @Test
-    public void mapsCovariantlyOverReturnValue() {
-        assertThat(CHECK_LENGTH.diMapR(Object::toString).apply("123").apply(3), is("true"));
-    }
-
-    @Test
-    public void mapsOverSecondArgumentAndReturnValueInSingleTransformation() {
-        assertThat(
-                CHECK_LENGTH.<String, String>diMap(
-                        Integer::parseInt,
-                        Object::toString
-                ).apply("123", "3"),
-                is("true")
-        );
-    }
-}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/MonadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
similarity index 58%
rename from src/test/java/com/jnape/palatable/lambda/functions/MonadicFunctionTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
index 80c87e879..06ef3d6cf 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/MonadicFunctionTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
@@ -5,20 +5,20 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 
-public class MonadicFunctionTest {
+public class Fn1Test {
 
     @Test
     public void fmapComposesFunctions() {
-        MonadicFunction<Integer, Integer> add2 = integer -> integer + 2;
-        MonadicFunction<Integer, String> toString = Object::toString;
+        Fn1<Integer, Integer> add2 = integer -> integer + 2;
+        Fn1<Integer, String> toString = Object::toString;
 
         assertThat(add2.fmap(toString).apply(2), is(toString.apply(add2.apply(2))));
     }
 
     @Test
     public void thenIsJustAnAliasForFmap() {
-        MonadicFunction<Integer, Integer> add2 = integer -> integer + 2;
-        MonadicFunction<Integer, String> toString = Object::toString;
+        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))));
     }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
new file mode 100644
index 000000000..12d62c4e2
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
@@ -0,0 +1,47 @@
+package com.jnape.palatable.lambda.functions;
+
+import com.jnape.palatable.lambda.functions.builtin.fn1.Id;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class Fn2Test {
+
+    private static final Fn2<String, Integer, Boolean> CHECK_LENGTH
+            = (string, length) -> string.length() == length;
+
+    @Test
+    public void flipSwapsArguments() {
+        assertThat(CHECK_LENGTH.flip().apply(3, "foo"), is(true));
+    }
+
+    @Test
+    public void canBePartiallyApplied() {
+        assertThat(CHECK_LENGTH.apply("quux").apply(4), is(true));
+    }
+
+    @Test
+    public void uncurries() {
+        assertThat(CHECK_LENGTH.uncurry().apply(tuple("abc", 3)), is(true));
+    }
+
+    @Test
+    public void functorProperties() {
+        assertThat(CHECK_LENGTH.fmap(f -> Id.id()).apply("foo").apply("bar"), is("bar"));
+    }
+
+    @Test
+    public void profunctorProperties() {
+        assertThat(CHECK_LENGTH.diMapL(Object::toString).apply(123).apply(3), is(true));
+        assertThat(CHECK_LENGTH.diMapR(fn -> fn.andThen(Object::toString)).apply("123").apply(3), is("true"));
+        assertThat(
+                CHECK_LENGTH.<String, Fn1<Integer, String>>diMap(
+                        Object::toString,
+                        fn -> fn.andThen(Object::toString)
+                ).apply("123").apply(3),
+                is("true")
+        );
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/Fn3Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn3Test.java
new file mode 100644
index 000000000..c35532933
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn3Test.java
@@ -0,0 +1,47 @@
+package com.jnape.palatable.lambda.functions;
+
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class Fn3Test {
+
+    private static final Fn3<Integer, Integer, Integer, Boolean> CHECK_MULTIPLICATION =
+            (multiplicand, multiplier, guessResult) -> multiplicand * multiplier == guessResult;
+
+    @Test
+    public void canBePartiallyApplied() {
+        assertThat(CHECK_MULTIPLICATION.apply(2).apply(4).apply(8), is(true));
+        assertThat(CHECK_MULTIPLICATION.apply(2).apply(4, 8), is(true));
+        assertThat(CHECK_MULTIPLICATION.apply(2, 4).apply(8), is(true));
+    }
+
+    @Test
+    public void flipsFirstAndSecondArgument() {
+        Fn3<String, Integer, String, String> concat3 = (a, b, c) -> a + b.toString() + c;
+        assertThat(concat3.flip().apply(1, "2", "3"), is("213"));
+    }
+
+    @Test
+    public void uncurries() {
+        assertThat(CHECK_MULTIPLICATION.uncurry().apply(tuple(2, 3), 6), is(true));
+    }
+
+    @Test
+    public void functorProperties() {
+        assertThat(CHECK_MULTIPLICATION.fmap(f -> f.fmap(g -> g.andThen(Object::toString))).apply(2).apply(3).apply(6), is("true"));
+    }
+
+    @Test
+    public void profunctorProperties() {
+        assertThat(CHECK_MULTIPLICATION.<String>diMapL(Integer::parseInt).apply("2").apply(3).apply(6), is(true));
+        assertThat(CHECK_MULTIPLICATION.diMapR(f -> f.fmap(g -> g.andThen(Object::toString))).apply(2).apply(3).apply(6), is("true"));
+        assertThat(CHECK_MULTIPLICATION.diMap((Fn1<String, Integer>) Integer::parseInt,
+                                              f -> f.fmap(g -> g.andThen(Object::toString)))
+                           .apply("2")
+                           .apply(3)
+                           .apply(6), is("true"));
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java
deleted file mode 100644
index fd0d2478c..000000000
--- a/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package com.jnape.palatable.lambda.functions;
-
-import org.junit.Test;
-
-import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-public class TriadicFunctionTest {
-
-    private static final TriadicFunction<Integer, Integer, Integer, Boolean> CHECK_MULTIPLICATION =
-            (multiplicand, multiplier, guessResult) -> multiplicand * multiplier == guessResult;
-
-    @Test
-    public void canBePartiallyApplied() {
-        assertThat(CHECK_MULTIPLICATION.apply(2).apply(4).apply(8), is(true));
-        assertThat(CHECK_MULTIPLICATION.apply(2).apply(4, 8), is(true));
-        assertThat(CHECK_MULTIPLICATION.apply(2, 4).apply(8), is(true));
-    }
-
-    @Test
-    public void uncurries() {
-        assertThat(CHECK_MULTIPLICATION.uncurry().apply(tuple(2, 3), 6), is(true));
-    }
-
-    @Test
-    public void flipsFirstAndSecondArgument() {
-        TriadicFunction<String, Integer, String, String> concat3 = (a, b, c) -> a + b.toString() + c;
-        assertThat(concat3.flip().apply(1, "2", "3"), is("213"));
-    }
-}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2Test.java
deleted file mode 100644
index c56e873e1..000000000
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2Test.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
-
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import org.junit.Test;
-
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Partial2.partial2;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-public class Partial2Test {
-
-    @Test
-    public void partiallyAppliesFunction() {
-        DyadicFunction<Integer, Integer, Integer> subtract = (minuend, subtrahend) -> minuend - subtrahend;
-
-        assertThat(partial2(subtract, 3).apply(2), is(1));
-    }
-}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3Test.java
deleted file mode 100644
index a40d53d02..000000000
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3Test.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
-
-import com.jnape.palatable.lambda.functions.TriadicFunction;
-import org.junit.Test;
-
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Partial3.partial3;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-public class Partial3Test {
-
-    @Test
-    public void partiallyAppliesFunction() {
-        TriadicFunction<String, String, String, String> concat = (s1, s2, s3) -> s1 + s2 + s3;
-
-        assertThat(partial3(concat, "foo").apply(" bar", " baz"), is("foo bar baz"));
-    }
-}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ConstantlyTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ConstantlyTest.java
similarity index 68%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ConstantlyTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ConstantlyTest.java
index 0543c48c3..1885d6902 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ConstantlyTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ConstantlyTest.java
@@ -1,8 +1,8 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
+package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import org.junit.Test;
 
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CycleTest.java
similarity index 74%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CycleTest.java
index 4025ebc5a..f9acf8d22 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CycleTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
+package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -8,8 +8,8 @@
 import testsupport.traits.InfiniteIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Cycle.cycle;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Cycle.cycle;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -18,7 +18,7 @@ public class CycleTest {
 
     @TestTraits({Laziness.class, ImmutableIteration.class, InfiniteIteration.class})
     public Cycle createTestSubject() {
-        return new Cycle();
+        return cycle();
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/IdTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/IdTest.java
new file mode 100644
index 000000000..168a09f30
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/IdTest.java
@@ -0,0 +1,15 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class IdTest {
+
+    @Test
+    public void returnsInput() {
+        assertThat(id().apply("anything"), is("anything"));
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/RepeatTest.java
similarity index 74%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/RepeatTest.java
index ab779679a..80112707f 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/RepeatTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
+package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -8,8 +8,8 @@
 import testsupport.traits.InfiniteIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -18,7 +18,7 @@ public class RepeatTest {
 
     @TestTraits({Laziness.class, ImmutableIteration.class, InfiniteIteration.class})
     public Repeat createTestSubject() {
-        return new Repeat();
+        return repeat();
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ReverseTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ReverseTest.java
similarity index 91%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ReverseTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ReverseTest.java
index 53d0e58f2..da6a94e45 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ReverseTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ReverseTest.java
@@ -1,4 +1,4 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
+package com.jnape.palatable.lambda.functions.builtin.fn1;
 
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -11,7 +11,7 @@
 
 import java.util.Iterator;
 
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Reverse.reverse;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AllTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java
similarity index 61%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AllTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java
index 993e4d0a2..e95465991 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AllTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java
@@ -1,15 +1,15 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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 static com.jnape.palatable.lambda.functions.builtin.dyadic.All.all;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.All.all;
 import static java.util.Arrays.asList;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
@@ -17,10 +17,10 @@
 @RunWith(Traits.class)
 public class AllTest {
 
-    private static final MonadicFunction<? super Number, Boolean> EVEN = x -> x.doubleValue() % 2 == 0;
+    private static final Fn1<? super Number, Boolean> EVEN = x -> x.doubleValue() % 2 == 0;
 
     @TestTraits({EmptyIterableSupport.class})
-    public MonadicFunction<Iterable<Object>, Boolean> createTestSubject() {
+    public Fn1<Iterable<Object>, Boolean> createTestSubject() {
         return all(constantly(true));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AnyTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java
similarity index 61%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AnyTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java
index 6ace0734a..8c5485d8c 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AnyTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java
@@ -1,15 +1,15 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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 static com.jnape.palatable.lambda.functions.builtin.dyadic.Any.any;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Any.any;
 import static java.util.Arrays.asList;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
@@ -17,10 +17,10 @@
 @RunWith(Traits.class)
 public class AnyTest {
 
-    public static final MonadicFunction<? super Integer, Boolean> EVEN = x -> x % 2 == 0;
+    public static final Fn1<? super Integer, Boolean> EVEN = x -> x % 2 == 0;
 
     @TestTraits({EmptyIterableSupport.class})
-    public MonadicFunction<Iterable<Object>, Boolean> createTestSubject() {
+    public Fn1<Iterable<Object>, Boolean> createTestSubject() {
         return any(constantly(true));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProductTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProductTest.java
similarity index 86%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProductTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProductTest.java
index d2813740e..b6b74e9e4 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProductTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProductTest.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -12,7 +12,7 @@
 import testsupport.traits.Laziness;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.CartesianProduct.cartesianProduct;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.CartesianProduct.cartesianProduct;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -22,7 +22,7 @@
 public class CartesianProductTest {
 
     @TestTraits({Laziness.class, ImmutableIteration.class, EmptyIterableSupport.class, FiniteIteration.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Tuple2<Integer, Object>>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Tuple2<Integer, Object>>> createTestSubject() {
         return cartesianProduct(asList(1, 2, 3));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java
similarity index 73%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java
index 953f9d031..329fd13e2 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -10,7 +10,7 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Drop.drop;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Drop.drop;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -19,7 +19,7 @@
 public class DropTest {
 
     @TestTraits({Laziness.class, ImmutableIteration.class, FiniteIteration.class, EmptyIterableSupport.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
         return drop(5);
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhileTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java
similarity index 77%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhileTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java
index a729ce240..352aa47b4 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhileTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.specialized.Predicate;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -11,8 +11,8 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.DropWhile.dropWhile;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.DropWhile.dropWhile;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.isEmpty;
@@ -22,7 +22,7 @@
 public class DropWhileTest {
 
     @TestTraits({Laziness.class, ImmutableIteration.class, FiniteIteration.class, EmptyIterableSupport.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
         return dropWhile(constantly(true));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/FilterTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FilterTest.java
similarity index 73%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/FilterTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FilterTest.java
index bd534cd0c..d718c55ef 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/FilterTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FilterTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.specialized.Predicate;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -11,8 +11,8 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Filter.filter;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Filter.filter;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -21,7 +21,7 @@
 public class FilterTest {
 
     @TestTraits({Laziness.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class})
-    public MonadicFunction<? extends Iterable, ?> createTraitsTestSubject() {
+    public Fn1<? extends Iterable, ?> createTraitsTestSubject() {
         return filter(constantly(true));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOfTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOfTest.java
similarity index 79%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOfTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOfTest.java
index 1bed4b247..c341257a9 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOfTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOfTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -10,8 +10,9 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.InGroupsOf.inGroupsOf;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.InGroupsOf.inGroupsOf;
 import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -20,7 +21,7 @@
 public class InGroupsOfTest {
 
     @TestTraits({Laziness.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Iterable<Object>>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Iterable<Object>>> createTestSubject() {
         return inGroupsOf(2);
     }
 
@@ -35,6 +36,6 @@ public void evenlyDistributesGroupedElementsOverIterable() {
     public void lastGroupIsUnfinishedIfIterableSizeNotEvenlyDivisibleByK() {
         Iterable<Integer> oneThroughFive = asList(1, 2, 3, 4, 5);
         Iterable<Iterable<Integer>> groups = inGroupsOf(2, oneThroughFive);
-        assertThat(groups, iterates(asList(1, 2), asList(3, 4), asList(5)));
+        assertThat(groups, iterates(asList(1, 2), asList(3, 4), singletonList(5)));
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/IterateTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/IterateTest.java
similarity index 63%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/IterateTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/IterateTest.java
index 984794010..961aa0d15 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/IterateTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/IterateTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -11,9 +11,9 @@
 
 import java.util.ArrayList;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Iterate.iterate;
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Iterate.iterate;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -21,7 +21,7 @@
 public class IterateTest {
 
     @TestTraits({Laziness.class, InfiniteIteration.class, ImmutableIteration.class})
-    public MonadicFunction<? extends Iterable, ? extends Iterable> createTestSubject() {
+    public Fn1<? extends Iterable, ? extends Iterable> createTestSubject() {
         return iterate(constantly(new ArrayList<>()));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MapTest.java
similarity index 67%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MapTest.java
index 8b2d5b5ce..eb4c68867 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MapTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -10,8 +10,8 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Map.map;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -20,13 +20,13 @@
 public class MapTest {
 
     @TestTraits({Laziness.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class})
-    public MonadicFunction<? extends Iterable, ?> createTraitsTestSubject() {
+    public Fn1<? extends Iterable, ?> createTraitsTestSubject() {
         return map(id());
     }
 
     @Test
     public void mapsInputsIntoOutputs() {
-        MonadicFunction<String, Integer> length = String::length;
+        Fn1<String, Integer> length = String::length;
         assertThat(
                 map(length, asList("one", "two", "three")),
                 iterates(3, 3, 5)
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2Test.java
new file mode 100644
index 000000000..1e3a05a9a
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2Test.java
@@ -0,0 +1,18 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn2;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Partial2.partial2;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class Partial2Test {
+
+    @Test
+    public void partiallyAppliesFunction() {
+        Fn2<Integer, Integer, Integer> subtract = (minuend, subtrahend) -> minuend - subtrahend;
+
+        assertThat(partial2(subtract, 3).apply(2), is(1));
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3Test.java
new file mode 100644
index 000000000..f939c68eb
--- /dev/null
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3Test.java
@@ -0,0 +1,18 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn3;
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Partial3.partial3;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class Partial3Test {
+
+    @Test
+    public void partiallyAppliesFunction() {
+        Fn3<String, String, String, String> concat = (s1, s2, s3) -> s1 + s2 + s3;
+
+        assertThat(partial3(concat, "foo").apply(" bar", " baz"), is("foo bar baz"));
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeftTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeftTest.java
similarity index 83%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeftTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeftTest.java
index 53d0bdcd5..8baf48eb8 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeftTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeftTest.java
@@ -1,10 +1,10 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import org.junit.Test;
 
 import java.util.Optional;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.ReduceLeft.reduceLeft;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ReduceLeft.reduceLeft;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
 import static org.hamcrest.core.Is.is;
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRightTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRightTest.java
similarity index 83%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRightTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRightTest.java
index 1f2e0032f..eb4bfb8d7 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRightTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRightTest.java
@@ -1,10 +1,10 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import org.junit.Test;
 
 import java.util.Optional;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.ReduceRight.reduceRight;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ReduceRight.reduceRight;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
 import static org.hamcrest.core.Is.is;
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeTest.java
similarity index 76%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeTest.java
index d53200943..51598a2a6 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -10,8 +10,9 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take;
+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 org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -19,7 +20,7 @@
 public class TakeTest {
 
     @TestTraits({FiniteIteration.class, EmptyIterableSupport.class, ImmutableIteration.class, Laziness.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
         return take(10);
     }
 
@@ -37,6 +38,6 @@ public void iteratesEntireIterableIfLessElementsThanLimit() {
 
     @Test
     public void takesNothingFromEmptyIterable() {
-        assertThat(take(1, asList()), iterates());
+        assertThat(take(1, emptyList()), iterates());
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhileTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhileTest.java
similarity index 79%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhileTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhileTest.java
index ed75773c0..871bd3a6e 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhileTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhileTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.specialized.Predicate;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -11,8 +11,8 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.TakeWhile.takeWhile;
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.TakeWhile.takeWhile;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.isEmpty;
@@ -22,7 +22,7 @@
 public class TakeWhileTest {
 
     @TestTraits({FiniteIteration.class, EmptyIterableSupport.class, ImmutableIteration.class, Laziness.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestObject() {
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestObject() {
         return takeWhile(constantly(true));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2Test.java
similarity index 68%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2Test.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2Test.java
index b909c6feb..6eff737aa 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2Test.java
@@ -1,9 +1,9 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+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.dyadic.Tupler2.tupler;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Tupler2.tupler;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/UnfoldrTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/UnfoldrTest.java
similarity index 70%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/UnfoldrTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/UnfoldrTest.java
index 9d53ee2f9..ed23697fa 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/UnfoldrTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/UnfoldrTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -12,8 +12,8 @@
 import java.util.Optional;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take;
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Unfoldr.unfoldr;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Unfoldr.unfoldr;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
 
@@ -21,7 +21,7 @@
 public class UnfoldrTest {
 
     @TestTraits({Laziness.class, InfiniteIteration.class, ImmutableIteration.class})
-    public MonadicFunction<? extends Iterable, ? extends Iterable> createTestSubject() {
+    public Fn1<? extends Iterable, ? extends Iterable> createTestSubject() {
         return unfoldr(x -> Optional.of(tuple(x, x)));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ZipTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ZipTest.java
similarity index 78%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ZipTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ZipTest.java
index 14efd3d28..69f1545d7 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ZipTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ZipTest.java
@@ -1,7 +1,7 @@
-package com.jnape.palatable.lambda.functions.builtin.dyadic;
+package com.jnape.palatable.lambda.functions.builtin.fn2;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -13,7 +13,7 @@
 import java.util.Arrays;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Zip.zip;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Zip.zip;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -22,7 +22,7 @@
 public class ZipTest {
 
     @TestTraits({Laziness.class, FiniteIteration.class, ImmutableIteration.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Tuple2<Object, Object>>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Tuple2<Object, Object>>> createTestSubject() {
         return zip(Arrays.asList(1, 2, 3));
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeftTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeftTest.java
similarity index 64%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeftTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeftTest.java
index 6f0e4757f..1e6da60ab 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeftTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeftTest.java
@@ -1,14 +1,15 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
+package com.jnape.palatable.lambda.functions.builtin.fn3;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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 static com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft.foldLeft;
+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.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 import static testsupport.functions.ExplainFold.explainFold;
@@ -17,8 +18,8 @@
 public class FoldLeftTest {
 
     @TestTraits({EmptyIterableSupport.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
-        return foldLeft((objects, o) -> objects, asList(new Object()));
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
+        return foldLeft((objects, o) -> objects, singletonList(new Object()));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRightTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRightTest.java
similarity index 64%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRightTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRightTest.java
index 9068f223b..b40915da7 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRightTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRightTest.java
@@ -1,14 +1,15 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
+package com.jnape.palatable.lambda.functions.builtin.fn3;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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 static com.jnape.palatable.lambda.functions.builtin.triadic.FoldRight.foldRight;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldRight.foldRight;
 import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 import static testsupport.functions.ExplainFold.explainFold;
@@ -17,8 +18,8 @@
 public class FoldRightTest {
 
     @TestTraits({EmptyIterableSupport.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
-        return foldRight((o, objects) -> objects, asList(new Object()));
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
+        return foldRight((o, objects) -> objects, singletonList(new Object()));
     }
 
     @Test
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeftTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeftTest.java
similarity index 79%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeftTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeftTest.java
index 621f94fc4..e031e22a2 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeftTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeftTest.java
@@ -1,6 +1,6 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
+package com.jnape.palatable.lambda.functions.builtin.fn3;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+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;
@@ -11,7 +11,7 @@
 
 import java.util.Collections;
 
-import static com.jnape.palatable.lambda.functions.builtin.triadic.ScanLeft.scanLeft;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.ScanLeft.scanLeft;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -20,7 +20,7 @@
 public class ScanLeftTest {
 
     @TestTraits({EmptyIterableSupport.class, FiniteIteration.class, Laziness.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
         return scanLeft((x, y) -> x, new Object());
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWithTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java
similarity index 74%
rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWithTest.java
rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java
index 604a0ff15..0fcc085ad 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWithTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java
@@ -1,8 +1,8 @@
-package com.jnape.palatable.lambda.functions.builtin.triadic;
+package com.jnape.palatable.lambda.functions.builtin.fn3;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.DyadicFunction;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
 import org.junit.Test;
@@ -12,8 +12,8 @@
 import testsupport.traits.Laziness;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
-import static com.jnape.palatable.lambda.functions.builtin.dyadic.Zip.zip;
-import static com.jnape.palatable.lambda.functions.builtin.triadic.ZipWith.zipWith;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Zip.zip;
+import static com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith.zipWith;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThat;
 import static testsupport.matchers.IterableMatcher.iterates;
@@ -22,7 +22,7 @@
 public class ZipWithTest {
 
     @TestTraits({Laziness.class, FiniteIteration.class, ImmutableIteration.class})
-    public MonadicFunction<Iterable<Object>, Iterable<Object>> createTestSubject() {
+    public Fn1<Iterable<Object>, Iterable<Object>> createTestSubject() {
         return zipWith((o, o2) -> new Object(), asList(1, 2, 3));
     }
 
@@ -31,7 +31,7 @@ public void zipsTwoIterablesTogetherWithFunction() {
         Iterable<Integer> oneThroughFive = asList(1, 2, 3, 4, 5);
         Iterable<Integer> sixThroughTen = asList(6, 7, 8, 9, 10);
 
-        DyadicFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
+        Fn2<Integer, Integer, Integer> add = (a, b) -> a + b;
         Iterable<Integer> sums = ZipWith.zipWith(add, oneThroughFive, sixThroughTen);
 
         assertThat(sums, iterates(7, 9, 11, 13, 15));
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java
deleted file mode 100644
index 8d4912d0e..000000000
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.jnape.palatable.lambda.functions.builtin.monadic;
-
-import org.junit.Test;
-
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-public class IdentityTest {
-
-    @Test
-    public void returnsInput() {
-        assertThat(new Identity<String>().apply("anything"), is("anything"));
-    }
-}
diff --git a/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java
index d5b779e6d..6d78c167d 100644
--- a/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java
@@ -1,12 +1,12 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
 import testsupport.applicatives.InvocationRecordingBifunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
 
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
@@ -14,7 +14,7 @@ public class BifunctorTest {
 
     @Test
     public void biMapLUsesIdentityForRightBiMapFunction() {
-        AtomicReference<MonadicFunction> rightInvocation = new AtomicReference<>();
+        AtomicReference<Fn1> rightInvocation = new AtomicReference<>();
         Bifunctor<String, Integer> bifunctor = new InvocationRecordingBifunctor<>(new AtomicReference<>(), rightInvocation);
         bifunctor.biMapL(String::toUpperCase);
         assertThat(rightInvocation.get(), is(id()));
@@ -22,7 +22,7 @@ public void biMapLUsesIdentityForRightBiMapFunction() {
 
     @Test
     public void biMapRUsesIdentityForLeftBiMapFunction() {
-        AtomicReference<MonadicFunction> leftInvocation = new AtomicReference<>();
+        AtomicReference<Fn1> leftInvocation = new AtomicReference<>();
         Bifunctor<String, Integer> bifunctor = new InvocationRecordingBifunctor<>(leftInvocation, new AtomicReference<>());
         bifunctor.biMapR(String::valueOf);
         assertThat(leftInvocation.get(), is(id()));
diff --git a/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java b/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java
index d99fb1478..63011de85 100644
--- a/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java
@@ -1,12 +1,12 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
 import testsupport.applicatives.InvocationRecordingProfunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
 
-import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
@@ -14,7 +14,7 @@ public class ProfunctorTest {
 
     @Test
     public void diMapLUsesIdentityForRightDiMapFunction() {
-        AtomicReference<MonadicFunction> rightInvocation = new AtomicReference<>();
+        AtomicReference<Fn1> rightInvocation = new AtomicReference<>();
         Profunctor<String, Integer> profunctor = new InvocationRecordingProfunctor<>(new AtomicReference<>(), rightInvocation);
         profunctor.diMapL(Object::toString);
         assertThat(rightInvocation.get(), is(id()));
@@ -22,7 +22,7 @@ public void diMapLUsesIdentityForRightDiMapFunction() {
 
     @Test
     public void diMapRUsesIdentityForLeftDiMapFunction() {
-        AtomicReference<MonadicFunction> leftInvocation = new AtomicReference<>();
+        AtomicReference<Fn1> leftInvocation = new AtomicReference<>();
         Profunctor<String, Integer> profunctor = new InvocationRecordingProfunctor<>(leftInvocation, new AtomicReference<>());
         profunctor.diMapR(String::valueOf);
         assertThat(leftInvocation.get(), is(id()));
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java
index 314f478d1..da1469db9 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java
@@ -1,6 +1,6 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
 
 import java.util.List;
@@ -13,7 +13,7 @@ public class MappingIteratorTest {
 
     @Test
     public void nextProducesMappedResult() {
-        MonadicFunction<String, Integer> stringToLength = String::length;
+        Fn1<String, Integer> stringToLength = String::length;
         List<String> words = asList("foo", "bar");
         MappingIterator<String, Integer> mappingIterator = new MappingIterator<>(stringToLength, words.iterator());
 
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java
index c5a2c9875..b597da2a0 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java
@@ -1,6 +1,6 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -17,7 +17,7 @@
 @RunWith(MockitoJUnitRunner.class)
 public class PredicatedDroppingIteratorTest {
 
-    private static final MonadicFunction<? super Integer, Boolean> EVEN = x -> x % 2 == 0;
+    private static final Fn1<? super Integer, Boolean> EVEN = x -> x % 2 == 0;
 
     @Mock private Iterator<Integer> iterator;
 
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
index ed93c0042..b082925ab 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
@@ -1,5 +1,6 @@
 package com.jnape.palatable.lambda.iterators;
 
+import com.jnape.palatable.lambda.functions.Fn2;
 import org.junit.Test;
 
 import java.util.NoSuchElementException;
@@ -11,7 +12,7 @@
 
 public class ScanningIteratorTest {
 
-    public static final com.jnape.palatable.lambda.functions.DyadicFunction<Integer, Integer, Integer> ADD = (x, y) -> x + y;
+    public static final Fn2<Integer, Integer, Integer> ADD = (x, y) -> x + y;
 
     @Test
     public void hasNextAtLeastForB() {
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java
index 85574e661..1aadfde06 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java
@@ -1,7 +1,7 @@
 package com.jnape.palatable.lambda.iterators;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
 
 import java.util.Optional;
@@ -12,7 +12,7 @@
 
 public class UnfoldingIteratorTest {
 
-    private static final MonadicFunction<Integer, Optional<Tuple2<String, Integer>>> STRINGIFY = x -> Optional.of(tuple(x.toString(), x + 1));
+    private static final Fn1<Integer, Optional<Tuple2<String, Integer>>> STRINGIFY = x -> Optional.of(tuple(x.toString(), x + 1));
 
     @Test
     public void hasNextIfFunctionProducesPresentValue() {
diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java
index acceae48f..e80c53acd 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java
@@ -1,6 +1,6 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
+import com.jnape.palatable.lambda.functions.Fn2;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -17,9 +17,9 @@
 @RunWith(MockitoJUnitRunner.class)
 public class ZippingIteratorTest {
 
-    @Mock private DyadicFunction<Object, Object, Object> zipper;
-    @Mock private Iterator<Object>                       as;
-    @Mock private Iterator<Object>                       bs;
+    @Mock private Fn2<Object, Object, Object> zipper;
+    @Mock private Iterator<Object>            as;
+    @Mock private Iterator<Object>            bs;
 
     private ZippingIterator<Object, Object, Object> zippingIterator;
 
diff --git a/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java b/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java
index 191df47c6..51b2fa24c 100644
--- a/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java
+++ b/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java
@@ -1,24 +1,24 @@
 package testsupport.applicatives;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
 
 public final class InvocationRecordingBifunctor<A, B> implements Bifunctor<A, B> {
-    private final AtomicReference<MonadicFunction> leftFn;
-    private final AtomicReference<MonadicFunction> rightFn;
+    private final AtomicReference<Fn1> leftFn;
+    private final AtomicReference<Fn1> rightFn;
 
-    public InvocationRecordingBifunctor(AtomicReference<MonadicFunction> leftFn,
-                                        AtomicReference<MonadicFunction> rightFn) {
+    public InvocationRecordingBifunctor(AtomicReference<Fn1> leftFn,
+                                        AtomicReference<Fn1> rightFn) {
         this.leftFn = leftFn;
         this.rightFn = rightFn;
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <C, D> Bifunctor<C, D> biMap(MonadicFunction<? super A, ? extends C> lFn,
-                                        MonadicFunction<? super B, ? extends D> rFn) {
+    public <C, D> Bifunctor<C, D> biMap(Fn1<? super A, ? extends C> lFn,
+                                        Fn1<? super B, ? extends D> rFn) {
         leftFn.set(lFn);
         rightFn.set(rFn);
         return (Bifunctor<C, D>) this;
diff --git a/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java b/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java
index 7cb8bef0d..a5de7891b 100644
--- a/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java
+++ b/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java
@@ -1,26 +1,25 @@
 package testsupport.applicatives;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Profunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
 
 public final class InvocationRecordingProfunctor<A, B> implements Profunctor<A, B> {
-    private final AtomicReference<MonadicFunction> leftFn;
-    private final AtomicReference<MonadicFunction> rightFn;
+    private final AtomicReference<Fn1> leftFn;
+    private final AtomicReference<Fn1> rightFn;
 
-    public InvocationRecordingProfunctor(AtomicReference<MonadicFunction> leftFn,
-                                         AtomicReference<MonadicFunction> rightFn) {
+    public InvocationRecordingProfunctor(AtomicReference<Fn1> leftFn,
+                                         AtomicReference<Fn1> rightFn) {
         this.leftFn = leftFn;
         this.rightFn = rightFn;
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <C, D> Profunctor<C, D> diMap(MonadicFunction<? super C, ? extends A> f1,
-                                         MonadicFunction<? super B, ? extends D> f2) {
-        leftFn.set(f1);
-        rightFn.set(f2);
+    public <C, D> Profunctor<C, D> diMap(Fn1<C, A> lFn, Fn1<B, D> rFn) {
+        leftFn.set(lFn);
+        rightFn.set(rFn);
         return (Profunctor<C, D>) this;
     }
 }
diff --git a/src/test/java/testsupport/functions/ExplainFold.java b/src/test/java/testsupport/functions/ExplainFold.java
index 9466e6339..d59a2378b 100644
--- a/src/test/java/testsupport/functions/ExplainFold.java
+++ b/src/test/java/testsupport/functions/ExplainFold.java
@@ -1,12 +1,12 @@
 package testsupport.functions;
 
-import com.jnape.palatable.lambda.functions.DyadicFunction;
+import com.jnape.palatable.lambda.functions.Fn2;
 
 import static java.lang.String.format;
 
 public class ExplainFold {
 
-    public static DyadicFunction<String, String, String> explainFold() {
+    public static Fn2<String, String, String> explainFold() {
         return (acc, x) -> format("(%s + %s)", acc, x);
     }
 }
diff --git a/src/test/java/testsupport/traits/EmptyIterableSupport.java b/src/test/java/testsupport/traits/EmptyIterableSupport.java
index bd361de21..a0d2d029a 100644
--- a/src/test/java/testsupport/traits/EmptyIterableSupport.java
+++ b/src/test/java/testsupport/traits/EmptyIterableSupport.java
@@ -1,14 +1,14 @@
 package testsupport.traits;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.traitor.traits.Trait;
 
 import java.util.ArrayList;
 
-public class EmptyIterableSupport implements Trait<MonadicFunction<Iterable, ?>> {
+public class EmptyIterableSupport implements Trait<Fn1<Iterable, ?>> {
 
     @Override
-    public void test(MonadicFunction<Iterable, ?> testSubject) {
+    public void test(Fn1<Iterable, ?> testSubject) {
         try {
             testSubject.apply(new ArrayList());
         } catch (Exception e) {
diff --git a/src/test/java/testsupport/traits/FiniteIteration.java b/src/test/java/testsupport/traits/FiniteIteration.java
index 5dc53be05..882632f17 100644
--- a/src/test/java/testsupport/traits/FiniteIteration.java
+++ b/src/test/java/testsupport/traits/FiniteIteration.java
@@ -1,6 +1,6 @@
 package testsupport.traits;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.traitor.traits.Trait;
 
 import static java.util.Arrays.asList;
@@ -8,10 +8,10 @@
 import static org.hamcrest.core.Is.is;
 import static testsupport.matchers.FiniteIterableMatcher.finitelyIterable;
 
-public class FiniteIteration implements Trait<MonadicFunction<Iterable, Iterable>> {
+public class FiniteIteration implements Trait<Fn1<Iterable, Iterable>> {
 
     @Override
-    public void test(MonadicFunction<Iterable, Iterable> testSubject) {
+    public void test(Fn1<Iterable, Iterable> testSubject) {
         Iterable result = testSubject.apply(asList(1, 2, 3));
         assertThat(result, is(finitelyIterable()));
     }
diff --git a/src/test/java/testsupport/traits/ImmutableIteration.java b/src/test/java/testsupport/traits/ImmutableIteration.java
index 2efd1dc2d..ce6e7db55 100644
--- a/src/test/java/testsupport/traits/ImmutableIteration.java
+++ b/src/test/java/testsupport/traits/ImmutableIteration.java
@@ -1,16 +1,16 @@
 package testsupport.traits;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.traitor.traits.Trait;
 
 import java.util.ArrayList;
 
 import static org.junit.Assert.fail;
 
-public class ImmutableIteration implements Trait<MonadicFunction<Iterable, Iterable>> {
+public class ImmutableIteration implements Trait<Fn1<Iterable, Iterable>> {
 
     @Override
-    public void test(MonadicFunction<Iterable, Iterable> testSubject) {
+    public void test(Fn1<Iterable, Iterable> testSubject) {
         Iterable result = testSubject.apply(new ArrayList());
         try {
             result.iterator().remove();
diff --git a/src/test/java/testsupport/traits/InfiniteIteration.java b/src/test/java/testsupport/traits/InfiniteIteration.java
index 785bd96aa..12072fe78 100644
--- a/src/test/java/testsupport/traits/InfiniteIteration.java
+++ b/src/test/java/testsupport/traits/InfiniteIteration.java
@@ -1,6 +1,6 @@
 package testsupport.traits;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.traitor.traits.Trait;
 
 import static java.util.Arrays.asList;
@@ -9,10 +9,10 @@
 import static org.hamcrest.core.Is.is;
 import static testsupport.matchers.FiniteIterableMatcher.finitelyIterable;
 
-public class InfiniteIteration implements Trait<MonadicFunction<Iterable, Iterable>> {
+public class InfiniteIteration implements Trait<Fn1<Iterable, Iterable>> {
 
     @Override
-    public void test(MonadicFunction<Iterable, Iterable> testSubject) {
+    public void test(Fn1<Iterable, Iterable> testSubject) {
         Iterable result = testSubject.apply(asList(1, 2, 3));
         assertThat(result, is(not(finitelyIterable())));
     }
diff --git a/src/test/java/testsupport/traits/Laziness.java b/src/test/java/testsupport/traits/Laziness.java
index 3aa3ca24e..216201df7 100644
--- a/src/test/java/testsupport/traits/Laziness.java
+++ b/src/test/java/testsupport/traits/Laziness.java
@@ -1,16 +1,16 @@
 package testsupport.traits;
 
-import com.jnape.palatable.lambda.functions.MonadicFunction;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.traitor.traits.Trait;
 
 import static org.junit.Assert.assertThat;
 import static testsupport.Mocking.mockIterable;
 import static testsupport.matchers.ZeroInvocationsMatcher.wasNeverInteractedWith;
 
-public class Laziness implements Trait<MonadicFunction<Iterable, Iterable>> {
+public class Laziness implements Trait<Fn1<Iterable, Iterable>> {
 
     @Override
-    public void test(MonadicFunction<Iterable, Iterable> testSubject) {
+    public void test(Fn1<Iterable, Iterable> testSubject) {
         Iterable iterable = mockIterable();
         testSubject.apply(iterable);