diff --git a/README.md b/README.md
index 2dd80178d..aa144b856 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,24 @@
 λ
 ======
 [![Build Status](https://travis-ci.org/palatable/lambda.svg)](https://travis-ci.org/palatable/lambda)
+[![Lambda](https://img.shields.io/maven-central/v/com.jnape.palatable/lambda.svg?maxAge=2592000)](http://search.maven.org/#search%7Cga%7C1%7Ccom.jnape.palatable.lambda)
 
 Functional patterns for Java 8
 
-Background
+#### Table of Contents
+
+ - [Background](#background)
+ - [Installation](#installation)
+ - [Examples](#examples)
+ - [ADTs](#adts)
+   - [HLists](#hlists)
+     - [Tuples](#tuples)
+   - [HMaps](#hmaps)
+   - [Either](#either)
+ - [Notes](#notes) 
+ - [License](#license)
+
+<a name="background">Background</a>
 ----------
 
 Lambda was born out of a desire to use some of the same canonical functions (e.g. `unfoldr`, `takeWhile`, `zipWith`) and functional patterns (e.g. `Functor` and friends) that are idiomatic in other languages and make them available for Java.
@@ -21,7 +35,7 @@ Generally, everything that lambda produces is lazily-evaluated (except for termi
 
 Although the library is currently (very) small, these values should always be the driving forces behind future growth.
 
-Installation
+<a name="installation">Installation</a>
 ------------
 
 Add the following dependency to your:
@@ -43,7 +57,7 @@ Add the following dependency to your:
 ```
   
 
-Examples
+<a name="examples">Examples</a>
 --------
 
 First, the obligatory `map`/`filter`/`reduce` example:
@@ -121,14 +135,14 @@ And have fun with 3s:
   //-> [[3, 6, 9], [12, 15, 18], [21, 24, 27]]
 ```
 
-Or check out [the tests](https://github.com/palatable/lambda/tree/master/src/test/java/com/jnape/palatable/lambda/functions/builtin) for more examples.
+Check out the [tests](https://github.com/palatable/lambda/tree/master/src/test/java/com/jnape/palatable/lambda/functions/builtin) or [javadoc](http://palatable.github.io/lambda/javadoc/) for more examples.
 
-ADTs
+<a name="adts">ADTs</a>
 ----
 
 In addition to the functions above, lambda also supports a few first-class [algebraic data types](https://www.wikiwand.com/en/Algebraic_data_type).
 
-### Heterogeneous Lists (HLists)
+### <a name="hlists">Heterogeneous Lists (HLists)</a>
 
 HLists are type-safe heterogeneous lists, meaning they can store elements of different types in the same list while facilitating certain type-safe interactions.
 
@@ -144,7 +158,7 @@ The following illustrates how the linear expansion of the recursive type signatu
   //nil.head() won't type-check
 ```
 
-#### Tuples
+#### <a name="tuples">Tuples</a>
 
 One of the primary downsides to using `HList`s in Java is how quickly the type signature grows.
 
@@ -187,7 +201,7 @@ Finally, all `Tuple*` classes are instances of both `Functor` and `Bifunctor`:
   System.out.println(mappedTuple3._3()); // prints 2
 ```
 
-### Heterogeneous Maps
+### <a name="hmaps">Heterogeneous Maps</a>
 
 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. 
 
@@ -202,7 +216,7 @@ HMaps are type-safe heterogeneous maps, meaning they can store mappings to diffe
   Optional<Integer> anotherIntValue = hmap.get(anotherIntKey); // Optional.empty
 ```    
 
-### Either
+### <a name="either">Either</a>
 
 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).
 
@@ -221,7 +235,14 @@ Rather than supporting explicit value unwrapping, `Either` supports many useful
 
 Check out the tests for [more examples](https://github.com/palatable/lambda/blob/master/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java) of ways to interact with `Either`.
 
-License
+<a name="notes">Notes</a>
+-----
+
+Wherever possible, _lambda_ maintains interface compatibility with similar, familiar core Java types. Some examples of where this works well is with both `Fn1` and `Predicate`, which extend `j.u.f.Function` and `j.u.f.Predicate`, respectively. In these examples, they also override any implemented methods to return their _lambda_-specific counterparts (`Fn1.compose` returning `Fn1` instead of `j.u.f.Function` as an example).
+
+Unfortunately, due to Java's type hierarchy and inheritance inconsistencies, this is not always possible. One surprising example of this is how `Fn1` extends `j.u.f.Function`, but `Fn2` does not extend `j.u.f.BiFunction`. This is because `j.u.f.BiFunction` itself does not extend `j.u.f.Function`, but it does define methods that collide with `j.u.f.Function`. For this reason, both `Fn1` and `Fn2` cannot extend their Java counterparts without sacrificing their own inheritance hierarchy. These types of asymmetries are, unfortunately, not uncommon; however, wherever these situations arise, measures are taken to attempt to ease the transition in and out of core Java types (in the case of `Fn2`, a supplemental `#toBiFunction` method is added). I do not take these inconveniences for granted, and I'm regularly looking for ways to minimize the negative impact of this as much as possible. Suggestions and use cases that highlight particular pain points here are particularly appreciated.
+
+<a name="license">License</a>
 -------
 
 _lambda_ is part of [palatable](http://www.github.com/palatable), which is distributed under [The MIT License](http://choosealicense.com/licenses/mit/).
diff --git a/pom.xml b/pom.xml
index 215859eae..b192e8e58 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,7 +9,7 @@
     </parent>
 
     <artifactId>lambda</artifactId>
-    <version>1.3</version>
+    <version>1.4</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 371e5d355..4fdd106fd 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/Either.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
@@ -1,14 +1,14 @@
 package com.jnape.palatable.lambda.adt;
 
-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;
 
 import java.util.Objects;
 import java.util.Optional;
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
@@ -43,7 +43,7 @@ public final R or(R defaultValue) {
      * @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) {
+    public final R recover(Function<? super L, ? extends R> recoveryFn) {
         return match(recoveryFn, id());
     }
 
@@ -54,7 +54,7 @@ public final R recover(Fn1<? super L, ? extends R> recoveryFn) {
      * @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) {
+    public final L forfeit(Function<? super R, ? extends L> forfeitFn) {
         return match(id(), forfeitFn);
     }
 
@@ -67,7 +67,7 @@ public final L forfeit(Fn1<? super R, ? extends L> forfeitFn) {
      * @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 {
+    public final <E extends RuntimeException> R orThrow(Function<? super L, ? extends E> throwableFn) throws E {
         return match(l -> {
             throw throwableFn.apply(l);
         }, id());
@@ -84,7 +84,7 @@ public final <E extends RuntimeException> R orThrow(Fn1<? super L, ? extends E>
      * @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) {
+    public final Either<L, R> filter(Function<? super R, Boolean> pred, Supplier<L> leftSupplier) {
         return flatMap(r -> pred.apply(r) ? right(r) : left(leftSupplier.get()));
     }
 
@@ -99,7 +99,7 @@ public final Either<L, R> filter(Fn1<? super R, Boolean> pred, Supplier<L> leftS
      * @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) {
+    public final <R2> Either<L, R2> flatMap(Function<? super R, ? extends Either<L, R2>> rightFn) {
         return flatMap(Either::left, rightFn);
     }
 
@@ -114,8 +114,8 @@ public final <R2> Either<L, R2> flatMap(Fn1<? super R, ? extends Either<L, R2>>
      * @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) {
+    public final <L2, R2> Either<L2, R2> flatMap(Function<? super L, ? extends Either<L2, R2>> leftFn,
+                                                 Function<? super R, ? extends Either<L2, R2>> rightFn) {
         return match(leftFn, rightFn);
     }
 
@@ -130,8 +130,8 @@ public final <L2, R2> Either<L2, R2> flatMap(Fn1<? super L, ? extends Either<L2,
      * @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,
+    public final Either<L, R> merge(BiFunction<? super L, ? super L, ? extends L> leftFn,
+                                    BiFunction<? 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)),
@@ -176,28 +176,28 @@ public Either<L, R> peek(Consumer<L> leftConsumer, Consumer<R> rightConsumer) {
      * @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);
+    public abstract <V> V match(Function<? super L, ? extends V> leftFn, Function<? super R, ? extends V> rightFn);
 
     @Override
-    public final <R2> Either<L, R2> fmap(Fn1<? super R, ? extends R2> fn) {
+    public final <R2> Either<L, R2> fmap(Function<? super R, ? extends R2> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public final <L2> Either<L2, R> biMapL(Fn1<? super L, ? extends L2> fn) {
+    public final <L2> Either<L2, R> biMapL(Function<? super L, ? extends L2> fn) {
         return (Either<L2, R>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public final <R2> Either<L, R2> biMapR(Fn1<? super R, ? extends R2> fn) {
+    public final <R2> Either<L, R2> biMapR(Function<? super R, ? extends R2> fn) {
         return (Either<L, R2>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public final <L2, R2> Either<L2, R2> biMap(Fn1<? super L, ? extends L2> leftFn,
-                                               Fn1<? super R, ? extends R2> rightFn) {
+    public final <L2, R2> Either<L2, R2> biMap(Function<? super L, ? extends L2> leftFn,
+                                               Function<? super R, ? extends R2> rightFn) {
         return match(l -> left(leftFn.apply(l)), r -> right(rightFn.apply(r)));
     }
 
@@ -229,7 +229,7 @@ public static <L, R> Either<L, R> fromOptional(Optional<R> optional, Supplier<L>
      */
     @SuppressWarnings("unchecked")
     public static <E extends Exception, L, R> Either<L, R> trying(CheckedSupplier<E, ? extends R> supplier,
-                                                                  Fn1<? super E, ? extends L> leftFn) {
+                                                                  Function<? super E, ? extends L> leftFn) {
         try {
             return right(supplier.get());
         } catch (Exception e) {
@@ -282,7 +282,7 @@ private Left(L l) {
         }
 
         @Override
-        public <V> V match(Fn1<? super L, ? extends V> leftFn, Fn1<? super R, ? extends V> rightFn) {
+        public <V> V match(Function<? super L, ? extends V> leftFn, Function<? super R, ? extends V> rightFn) {
             return leftFn.apply(l);
         }
 
@@ -312,7 +312,7 @@ private Right(R r) {
         }
 
         @Override
-        public <V> V match(Fn1<? super L, ? extends V> leftFn, Fn1<? super R, ? extends V> rightFn) {
+        public <V> V match(Function<? super L, ? extends V> leftFn, Function<? super R, ? extends V> rightFn) {
             return rightFn.apply(r);
         }
 
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
index f651328a8..6e62e1a66 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java
@@ -2,10 +2,9 @@
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
 import com.jnape.palatable.lambda.adt.hlist.HList.HNil;
-import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Functor;
 
-import java.util.RandomAccess;
+import java.util.function.Function;
 
 /**
  * A singleton HList. Supports random access.
@@ -17,7 +16,7 @@
  * @see Tuple4
  * @see Tuple5
  */
-public class SingletonHList<_1> extends HCons<_1, HNil> implements Functor<_1>, RandomAccess {
+public class SingletonHList<_1> extends HCons<_1, HNil> implements Functor<_1> {
 
     SingletonHList(_1 _1) {
         super(_1, nil());
@@ -29,7 +28,7 @@ public <_0> Tuple2<_0, _1> cons(_0 _0) {
     }
 
     @Override
-    public <_1Prime> SingletonHList<_1Prime> fmap(Fn1<? super _1, ? extends _1Prime> fn) {
+    public <_1Prime> SingletonHList<_1Prime> fmap(Function<? 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 222fb1f23..b73f57e05 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,11 +1,11 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-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;
+import java.util.function.Function;
 
 /**
  * A 2-element tuple product type, implemented as a specialized HList. Supports random access.
@@ -68,25 +68,25 @@ public _2 setValue(_2 value) {
     }
 
     @Override
-    public <_2Prime> Tuple2<_1, _2Prime> fmap(Fn1<? super _2, ? extends _2Prime> fn) {
+    public <_2Prime> Tuple2<_1, _2Prime> fmap(Function<? super _2, ? extends _2Prime> fn) {
         return tuple(_1(), fn.apply(_2()));
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_1Prime> Tuple2<_1Prime, _2> biMapL(Fn1<? super _1, ? extends _1Prime> fn) {
+    public <_1Prime> Tuple2<_1Prime, _2> biMapL(Function<? super _1, ? extends _1Prime> fn) {
         return (Tuple2<_1Prime, _2>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_2Prime> Tuple2<_1, _2Prime> biMapR(Fn1<? super _2, ? extends _2Prime> fn) {
+    public <_2Prime> Tuple2<_1, _2Prime> biMapR(Function<? super _2, ? extends _2Prime> fn) {
         return (Tuple2<_1, _2Prime>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(Fn1<? super _1, ? extends _1Prime> lFn,
-                                                             Fn1<? super _2, ? extends _2Prime> rFn) {
+    public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(Function<? super _1, ? extends _1Prime> lFn,
+                                                             Function<? super _2, ? extends _2Prime> rFn) {
         return new Tuple2<>(lFn.apply(_1()), tail().fmap(rFn));
     }
 
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 acc840e06..431eeb375 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,10 +1,11 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
 
+import java.util.function.Function;
+
 /**
  * A 3-element tuple product type, implemented as a specialized HList. Supports random access.
  *
@@ -62,25 +63,25 @@ public _3 _3() {
     }
 
     @Override
-    public <_3Prime> Tuple3<_1, _2, _3Prime> fmap(Fn1<? super _3, ? extends _3Prime> fn) {
+    public <_3Prime> Tuple3<_1, _2, _3Prime> fmap(Function<? super _3, ? extends _3Prime> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_2Prime> Tuple3<_1, _2Prime, _3> biMapL(Fn1<? super _2, ? extends _2Prime> fn) {
+    public <_2Prime> Tuple3<_1, _2Prime, _3> biMapL(Function<? super _2, ? extends _2Prime> fn) {
         return (Tuple3<_1, _2Prime, _3>) Bifunctor.super.biMapL(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_3Prime> Tuple3<_1, _2, _3Prime> biMapR(Fn1<? super _3, ? extends _3Prime> fn) {
+    public <_3Prime> Tuple3<_1, _2, _3Prime> biMapR(Function<? super _3, ? extends _3Prime> fn) {
         return (Tuple3<_1, _2, _3Prime>) Bifunctor.super.biMapR(fn);
     }
 
     @Override
-    public <_2Prime, _3Prime> Tuple3<_1, _2Prime, _3Prime> biMap(Fn1<? super _2, ? extends _2Prime> lFn,
-                                                                 Fn1<? super _3, ? extends _3Prime> rFn) {
+    public <_2Prime, _3Prime> Tuple3<_1, _2Prime, _3Prime> biMap(Function<? super _2, ? extends _2Prime> lFn,
+                                                                 Function<? 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 38208b713..35effe953 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,10 +1,11 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
 
+import java.util.function.Function;
+
 /**
  * A 4-element tuple product type, implemented as a specialized HList. Supports random access.
  *
@@ -74,25 +75,25 @@ public _4 _4() {
     }
 
     @Override
-    public <_4Prime> Tuple4<_1, _2, _3, _4Prime> fmap(Fn1<? super _4, ? extends _4Prime> fn) {
+    public <_4Prime> Tuple4<_1, _2, _3, _4Prime> fmap(Function<? super _4, ? extends _4Prime> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_3Prime> Tuple4<_1, _2, _3Prime, _4> biMapL(Fn1<? super _3, ? extends _3Prime> fn) {
+    public <_3Prime> Tuple4<_1, _2, _3Prime, _4> biMapL(Function<? 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(Fn1<? super _4, ? extends _4Prime> fn) {
+    public <_4Prime> Tuple4<_1, _2, _3, _4Prime> biMapR(Function<? 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(Fn1<? super _3, ? extends _3Prime> lFn,
-                                                                     Fn1<? super _4, ? extends _4Prime> rFn) {
+    public <_3Prime, _4Prime> Tuple4<_1, _2, _3Prime, _4Prime> biMap(Function<? super _3, ? extends _3Prime> lFn,
+                                                                     Function<? 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 49cf2c29a..a138f4d76 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,10 +1,11 @@
 package com.jnape.palatable.lambda.adt.hlist;
 
 import com.jnape.palatable.lambda.adt.hlist.HList.HCons;
-import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.Functor;
 
+import java.util.function.Function;
+
 /**
  * A 5-element tuple product type, implemented as a specialized HList. Supports random access.
  *
@@ -86,25 +87,25 @@ public _5 _5() {
     }
 
     @Override
-    public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> fmap(Fn1<? super _5, ? extends _5Prime> fn) {
+    public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> fmap(Function<? super _5, ? extends _5Prime> fn) {
         return biMapR(fn);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <_4Prime> Tuple5<_1, _2, _3, _4Prime, _5> biMapL(Fn1<? super _4, ? extends _4Prime> fn) {
+    public <_4Prime> Tuple5<_1, _2, _3, _4Prime, _5> biMapL(Function<? 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(Fn1<? super _5, ? extends _5Prime> fn) {
+    public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> biMapR(Function<? 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(Fn1<? super _4, ? extends _4Prime> lFn,
-                                                                         Fn1<? super _5, ? extends _5Prime> rFn) {
+    public <_4Prime, _5Prime> Tuple5<_1, _2, _3, _4Prime, _5Prime> biMap(Function<? super _4, ? extends _4Prime> lFn,
+                                                                         Function<? super _5, ? extends _5Prime> rFn) {
         return new Tuple5<>(_1(), tail().biMap(lFn, rFn));
     }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
index a5eda64ea..3443ac535 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
@@ -31,20 +31,20 @@ public interface Fn1<A, B> extends Functor<B>, Profunctor<A, B>, Function<A, B>
      * @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) {
+    default <C> Fn1<A, C> then(Function<? 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
+     * @param f   the function to invoke with this function's return value
      * @return a function representing the composition of this function and f
-     * @see Fn1#then(Fn1)
+     * @see Fn1#then(Function)
      */
     @Override
-    default <C> Fn1<A, C> fmap(Fn1<? super B, ? extends C> f) {
+    default <C> Fn1<A, C> fmap(Function<? super B, ? extends C> f) {
         return a -> f.apply(apply(a));
     }
 
@@ -52,12 +52,12 @@ default <C> Fn1<A, C> fmap(Fn1<? super B, ? extends C> f) {
      * 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
+     * @param fn  the contravariant argument mapping function
      * @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) {
+    default <Z> Fn1<Z, B> diMapL(Function<Z, A> fn) {
         return (Fn1<Z, B>) Profunctor.super.diMapL(fn);
     }
 
@@ -65,27 +65,27 @@ default <Z> Fn1<Z, B> diMapL(Fn1<Z, A> 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
+     * @param fn  the covariant result mapping function
      * @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) {
+    default <C> Fn1<A, C> diMapR(Function<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
+     * @param lFn the contravariant argument mapping function
+     * @param rFn the covariant result mapping function
      * @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);
+    default <Z, C> Fn1<Z, C> diMap(Function<Z, A> lFn, Function<B, C> rFn) {
+        return lFn.andThen(this).andThen(rFn)::apply;
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
index 5f9b6677b..4078bfa77 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
@@ -2,6 +2,8 @@
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 
+import java.util.function.BiFunction;
+
 /**
  * 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
@@ -53,4 +55,14 @@ default Fn2<B, A, C> flip() {
     default Fn1<Tuple2<A, B>, C> uncurry() {
         return (ab) -> apply(ab._1(), ab._2());
     }
+
+    /**
+     * View this <code>Fn2</code> as a <code>j.u.f.BiFunction</code>.
+     *
+     * @return the same logic as a <code>BiFunction</code>
+     * @see BiFunction
+     */
+    default BiFunction<A, B, C> toBiFunction() {
+        return this::apply;
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java
index d3d96ccb4..c0a4f2cc7 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java
@@ -3,6 +3,8 @@
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 
+import java.util.function.Function;
+
 /**
  * Eagerly apply a predicate to each element in an <code>Iterable</code>, returning <code>true</code> if every element
  * satisfies the predicate, and <code>false</code> otherwise. This method short-circuits on the first <code>false</code>
@@ -11,13 +13,13 @@
  * @param <A> The input Iterable element type
  * @see Any
  */
-public final class All<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Boolean> {
+public final class All<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Boolean> {
 
     private All() {
     }
 
     @Override
-    public Boolean apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public Boolean apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
         for (A a : as)
             if (!predicate.apply(a))
                 return false;
@@ -29,11 +31,11 @@ public static <A> All<A> all() {
         return new All<>();
     }
 
-    public static <A> Fn1<Iterable<A>, Boolean> all(Fn1<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Boolean> all(Function<? super A, Boolean> predicate) {
         return All.<A>all().apply(predicate);
     }
 
-    public static <A> Boolean all(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Boolean all(Function<? 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/fn2/Any.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java
index 37a83bbe6..716217884 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java
@@ -3,6 +3,8 @@
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 
+import java.util.function.Function;
+
 /**
  * Eagerly apply a predicate to each element in an <code>Iterable</code>, returning <code>true</code> if any element
  * satisfies the predicate, and <code>false</code> otherwise. This method short-circuits on the first <code>true</code>
@@ -11,13 +13,13 @@
  * @param <A> The input Iterable element type
  * @see All
  */
-public final class Any<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Boolean> {
+public final class Any<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Boolean> {
 
     private Any() {
     }
 
     @Override
-    public Boolean apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public Boolean apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
         for (A a : as)
             if (predicate.apply(a))
                 return true;
@@ -29,11 +31,11 @@ public static <A> Any<A> any() {
         return new Any<>();
     }
 
-    public static <A> Fn1<Iterable<A>, Boolean> any(Fn1<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Boolean> any(Function<? super A, Boolean> predicate) {
         return Any.<A>any().apply(predicate);
     }
 
-    public static <A> Boolean any(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Boolean any(Function<? 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/fn2/DropWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
index 59be5363e..ceabf8241 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java
@@ -4,6 +4,8 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.PredicatedDroppingIterator;
 
+import java.util.function.Function;
+
 /**
  * Lazily limit the <code>Iterable</code> by skipping the first contiguous group of elements that satisfy the predicate,
  * beginning iteration at the first element for which the predicate evaluates to <code>false</code>.
@@ -14,13 +16,13 @@
  * @see TakeWhile
  */
 
-public final class DropWhile<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Iterable<A>> {
+public final class DropWhile<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Iterable<A>> {
 
     private DropWhile() {
     }
 
     @Override
-    public Iterable<A> apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public Iterable<A> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
         return () -> new PredicatedDroppingIterator<>(predicate, as.iterator());
     }
 
@@ -28,11 +30,11 @@ public static <A> DropWhile<A> dropWhile() {
         return new DropWhile<>();
     }
 
-    public static <A> Fn1<Iterable<A>, Iterable<A>> dropWhile(Fn1<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> dropWhile(Function<? super A, Boolean> predicate) {
         return DropWhile.<A>dropWhile().apply(predicate);
     }
 
-    public static <A> Iterable<A> dropWhile(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Iterable<A> dropWhile(Function<? 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/fn2/Filter.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
index 2b6d7c610..eb0159883 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java
@@ -4,6 +4,8 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.FilteringIterator;
 
+import java.util.function.Function;
+
 /**
  * Lazily apply a predicate to each element in an <code>Iterable</code>, returning an <code>Iterable</code> of just the
  * elements for which the predicate evaluated to <code>true</code>.
@@ -12,13 +14,13 @@
  * @see TakeWhile
  * @see DropWhile
  */
-public final class Filter<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Iterable<A>> {
+public final class Filter<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Iterable<A>> {
 
     private Filter() {
     }
 
     @Override
-    public Iterable<A> apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public Iterable<A> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
         return () -> new FilteringIterator<>(predicate, as.iterator());
     }
 
@@ -26,11 +28,11 @@ public static <A> Filter<A> filter() {
         return new Filter<>();
     }
 
-    public static <A> Fn1<Iterable<A>, Iterable<A>> filter(Fn1<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> filter(Function<? super A, Boolean> predicate) {
         return Filter.<A>filter().apply(predicate);
     }
 
-    public static <A> Iterable<A> filter(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Iterable<A> filter(Function<? 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/fn2/Iterate.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java
index 8a7209567..afc132cd8 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java
@@ -2,11 +2,12 @@
 
 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;
+import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Unfoldr.unfoldr;
 
 /**
  * Lazily generate an infinite <code>Iterable</code> from the successive applications of the function first to the
@@ -15,25 +16,25 @@
  *
  * @param <A> The Iterable element type
  */
-public final class Iterate<A> implements Fn2<Fn1<? super A, ? extends A>, A, Iterable<A>> {
+public final class Iterate<A> implements Fn2<Function<? super A, ? extends A>, A, Iterable<A>> {
 
     private Iterate() {
     }
 
     @Override
-    public Iterable<A> apply(Fn1<? super A, ? extends A> fn, A seed) {
-        return () -> new UnfoldingIterator<>(a -> Optional.of(tuple(a, fn.apply(a))), seed);
+    public Iterable<A> apply(Function<? super A, ? extends A> fn, A seed) {
+        return unfoldr(a -> Optional.of(tuple(a, fn.apply(a))), seed);
     }
 
     public static <A> Iterate<A> iterate() {
         return new Iterate<>();
     }
 
-    public static <A> Fn1<A, Iterable<A>> iterate(Fn1<? super A, ? extends A> fn) {
+    public static <A> Fn1<A, Iterable<A>> iterate(Function<? super A, ? extends A> fn) {
         return Iterate.<A>iterate().apply(fn);
     }
 
-    public static <A> Iterable<A> iterate(Fn1<? super A, ? extends A> fn, A seed) {
+    public static <A> Iterable<A> iterate(Function<? 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
index 3aecce3a5..9805d54af 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java
@@ -4,6 +4,8 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.MappingIterator;
 
+import java.util.function.Function;
+
 /**
  * Lazily apply a function to each element in an <code>Iterable</code>, producing an <code>Iterable</code> of the mapped
  * results.
@@ -11,13 +13,13 @@
  * @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>> {
+public final class Map<A, B> implements Fn2<Function<? super A, ? extends B>, Iterable<A>, Iterable<B>> {
 
     private Map() {
     }
 
     @Override
-    public Iterable<B> apply(Fn1<? super A, ? extends B> fn, Iterable<A> as) {
+    public Iterable<B> apply(Function<? super A, ? extends B> fn, Iterable<A> as) {
         return () -> new MappingIterator<>(fn, as.iterator());
     }
 
@@ -25,11 +27,11 @@ 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) {
+    public static <A, B> Fn1<Iterable<A>, Iterable<B>> map(Function<? 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) {
+    public static <A, B> Iterable<B> map(Function<? 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
index a7292ad93..f2895b906 100644
--- 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
@@ -3,34 +3,36 @@
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 
+import java.util.function.BiFunction;
+
 /**
- * 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)}.
+ * Partially apply (fix) the first argument of a <code>{@link BiFunction}</code>, producing an <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>> {
+public final class Partial2<A, B, C> implements Fn2<BiFunction<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 Fn1<B, C> apply(BiFunction<A, B, C> fn, A a) {
+        return b -> fn.apply(a, b);
     }
 
-    public static <A, B, C> Partial2<Fn2<A, B, C>, A, Fn1<B, C>> partial2() {
+    public static <A, B, C> Partial2<BiFunction<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<A, Fn1<B, C>> partial2(BiFunction<A, B, C> fn) {
+        return Partial2.<A, B, C>partial2().apply(new Partial2<A, B, C>().toBiFunction(), fn);
     }
 
-    public static <A, B, C> Fn1<B, C> partial2(Fn2<A, B, C> fn, A a) {
+    public static <A, B, C> Fn1<B, C> partial2(BiFunction<A, B, C> fn, A a) {
         return partial2(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
index b493cf5db..e8f595576 100644
--- 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
@@ -5,11 +5,12 @@
 
 import java.util.Iterator;
 import java.util.Optional;
+import java.util.function.BiFunction;
 
 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
+ * Given an <code>Iterable</code> of <code>A</code>s and a <code>{@link BiFunction}&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
@@ -22,13 +23,13 @@
  * @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>> {
+public final class ReduceLeft<A> implements Fn2<BiFunction<? 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) {
+    public Optional<A> apply(BiFunction<? super A, ? super A, ? extends A> fn, Iterable<A> as) {
         Iterator<A> iterator = as.iterator();
         if (!iterator.hasNext())
             return Optional.empty();
@@ -40,11 +41,11 @@ 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) {
+    public static <A> Fn1<Iterable<A>, Optional<A>> reduceLeft(BiFunction<? 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) {
+    public static <A> Optional<A> reduceLeft(BiFunction<? 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
index 1a49359cf..b12efe118 100644
--- 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
@@ -4,12 +4,13 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 
 import java.util.Optional;
+import java.util.function.BiFunction;
 
 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
+ * Given an <code>Iterable</code> of <code>A</code>s and a <code>{@link BiFunction}&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
@@ -22,25 +23,25 @@
  * @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>> {
+public final class ReduceRight<A> implements Fn2<BiFunction<? 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 final Optional<A> apply(BiFunction<? super A, ? super A, ? extends A> fn, Iterable<A> as) {
+        return reduceLeft((b, a) -> fn.apply(a, b), 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) {
+    public static <A> Fn1<Iterable<A>, Optional<A>> reduceRight(BiFunction<? 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) {
+    public static <A> Optional<A> reduceRight(BiFunction<? 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/fn2/TakeWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
index 8cec722e5..595e5112b 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java
@@ -4,6 +4,8 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.iterators.PredicatedTakingIterator;
 
+import java.util.function.Function;
+
 /**
  * Lazily limit the <code>Iterable</code> to the first group of contiguous elements that satisfy the predicate by
  * iterating up to, but not including, the first element for which the predicate evaluates to <code>false</code>.
@@ -13,13 +15,13 @@
  * @see Filter
  * @see DropWhile
  */
-public final class TakeWhile<A> implements Fn2<Fn1<? super A, Boolean>, Iterable<A>, Iterable<A>> {
+public final class TakeWhile<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Iterable<A>> {
 
     private TakeWhile() {
     }
 
     @Override
-    public Iterable<A> apply(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public Iterable<A> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
         return () -> new PredicatedTakingIterator<>(predicate, as.iterator());
     }
 
@@ -27,12 +29,11 @@ public static <A> TakeWhile<A> takeWhile() {
         return new TakeWhile<>();
     }
 
-    public static <A> Fn1<Iterable<A>, Iterable<A>> takeWhile(
-            Fn1<? super A, Boolean> predicate) {
+    public static <A> Fn1<Iterable<A>, Iterable<A>> takeWhile(Function<? super A, Boolean> predicate) {
         return TakeWhile.<A>takeWhile().apply(predicate);
     }
 
-    public static <A> Iterable<A> takeWhile(Fn1<? super A, Boolean> predicate, Iterable<A> as) {
+    public static <A> Iterable<A> takeWhile(Function<? 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/fn2/Unfoldr.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
index 6befaf292..3fc3cb2b6 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java
@@ -6,6 +6,7 @@
 import com.jnape.palatable.lambda.iterators.UnfoldingIterator;
 
 import java.util.Optional;
+import java.util.function.Function;
 
 /**
  * Given an initial seed value and a function that takes the seed type and produces an <code>Optional&lt;{@link
@@ -28,13 +29,13 @@
  * @param <A> The output Iterable element type
  * @param <B> The unfolding function input type
  */
-public final class Unfoldr<A, B> implements Fn2<Fn1<B, Optional<Tuple2<A, B>>>, B, Iterable<A>> {
+public final class Unfoldr<A, B> implements Fn2<Function<B, Optional<Tuple2<A, B>>>, B, Iterable<A>> {
 
     private Unfoldr() {
     }
 
     @Override
-    public Iterable<A> apply(Fn1<B, Optional<Tuple2<A, B>>> fn, B b) {
+    public Iterable<A> apply(Function<B, Optional<Tuple2<A, B>>> fn, B b) {
         return () -> new UnfoldingIterator<>(fn, b);
     }
 
@@ -42,11 +43,11 @@ public static <A, B> Unfoldr<A, B> unfoldr() {
         return new Unfoldr<>();
     }
 
-    public static <A, B> Fn1<B, Iterable<A>> unfoldr(Fn1<B, Optional<Tuple2<A, B>>> fn) {
+    public static <A, B> Fn1<B, Iterable<A>> unfoldr(Function<B, Optional<Tuple2<A, B>>> fn) {
         return Unfoldr.<A, B>unfoldr().apply(fn);
     }
 
-    public static <A, B> Iterable<A> unfoldr(Fn1<B, Optional<Tuple2<A, B>>> fn, B b) {
+    public static <A, B> Iterable<A> unfoldr(Function<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/fn2/Zip.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java
index 1cc8838ca..b9ae36cf6 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java
@@ -4,7 +4,6 @@
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 
-import static com.jnape.palatable.lambda.functions.builtin.fn2.Tupler2.tupler;
 import static com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith.zipWith;
 
 /**
@@ -23,7 +22,7 @@ private Zip() {
 
     @Override
     public Iterable<Tuple2<A, B>> apply(Iterable<A> as, Iterable<B> bs) {
-        return zipWith(tupler(), as, bs);
+        return zipWith(Tupler2.<A, B>tupler().toBiFunction(), as, bs);
     }
 
     public static <A, B> Zip<A, B> zip() {
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
index 97f5a658c..a64e099ae 100644
--- 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
@@ -4,12 +4,14 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.Fn3;
 
+import java.util.function.BiFunction;
+
 /**
- * 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>.
+ * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link
+ * BiFunction}&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>.
@@ -18,13 +20,13 @@
  * @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> {
+public final class FoldLeft<A, B> implements Fn3<BiFunction<? 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) {
+    public B apply(BiFunction<? super B, ? super A, ? extends B> fn, B acc, Iterable<A> as) {
         B accumulation = acc;
         for (A a : as)
             accumulation = fn.apply(accumulation, a);
@@ -35,15 +37,15 @@ 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) {
+    public static <A, B> Fn2<B, Iterable<A>, B> foldLeft(BiFunction<? 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) {
+    public static <A, B> Fn1<Iterable<A>, B> foldLeft(BiFunction<? 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) {
+    public static <A, B> B foldLeft(BiFunction<? 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
index c5717a50d..545ee5eb6 100644
--- 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
@@ -4,15 +4,17 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functions.Fn3;
 
+import java.util.function.BiFunction;
+
 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>.
+ * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link
+ * BiFunction}&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>.
@@ -21,29 +23,29 @@
  * @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> {
+public final class FoldRight<A, B> implements Fn3<BiFunction<? 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 B apply(BiFunction<? super A, ? super B, ? extends B> fn, B acc, Iterable<A> as) {
+        return foldLeft((b, a) -> fn.apply(a, b), 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) {
+    public static <A, B> Fn2<B, Iterable<A>, B> foldRight(BiFunction<? 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) {
+    public static <A, B> Fn1<Iterable<A>, B> foldRight(BiFunction<? 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) {
+    public static <A, B> B foldRight(BiFunction<? 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
index 84a513223..5dcb2a309 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java
@@ -5,24 +5,26 @@
 import com.jnape.palatable.lambda.functions.Fn3;
 import com.jnape.palatable.lambda.iterators.ScanningIterator;
 
+import java.util.function.BiFunction;
+
 /**
- * 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).
+ * Given an <code>Iterable</code> of <code>A</code>s, a starting value <code>B</code>, and a <code>{@link
+ * BiFunction}&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>> {
+public final class ScanLeft<A, B> implements Fn3<BiFunction<? 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) {
+    public Iterable<B> apply(BiFunction<? super B, ? super A, ? extends B> fn, B b, Iterable<A> as) {
         return () -> new ScanningIterator<>(fn, b, as.iterator());
     }
 
@@ -30,15 +32,15 @@ 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) {
+    public static <A, B> Fn2<B, Iterable<A>, Iterable<B>> scanLeft(BiFunction<? 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) {
+    public static <A, B> Fn1<Iterable<A>, Iterable<B>> scanLeft(BiFunction<? 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) {
+    public static <A, B> Iterable<B> scanLeft(BiFunction<? 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
index eb5ea480b..5692295f8 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java
@@ -5,6 +5,8 @@
 import com.jnape.palatable.lambda.functions.Fn3;
 import com.jnape.palatable.lambda.iterators.ZippingIterator;
 
+import java.util.function.BiFunction;
+
 /**
  * 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
@@ -15,13 +17,13 @@
  * @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>> {
+public final class ZipWith<A, B, C> implements Fn3<BiFunction<? 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) {
+    public Iterable<C> apply(BiFunction<? super A, ? super B, ? extends C> zipper, Iterable<A> as, Iterable<B> bs) {
         return () -> new ZippingIterator<>(zipper, as.iterator(), bs.iterator());
     }
 
@@ -30,16 +32,16 @@ public static <A, B, C> ZipWith<A, B, C> zipWith() {
     }
 
     public static <A, B, C> Fn2<Iterable<A>, Iterable<B>, Iterable<C>> zipWith(
-            Fn2<? super A, ? super B, ? extends C> zipper) {
+            BiFunction<? 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,
+    public static <A, B, C> Fn1<Iterable<B>, Iterable<C>> zipWith(BiFunction<? 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,
+    public static <A, B, C> Iterable<C> zipWith(BiFunction<? 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 f9c2037f4..811fcf283 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
@@ -38,7 +38,7 @@ default <Z> Predicate<Z> compose(Function<? super Z, ? extends A> before) {
      */
     @Override
     @SuppressWarnings("unchecked")
-    default <Z> Predicate<Z> diMapL(Fn1<Z, A> fn) {
+    default <Z> Predicate<Z> diMapL(Function<Z, A> fn) {
         return Fn1.super.diMapL(fn)::apply;
     }
 
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 906c20a8c..496c97021 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java
@@ -1,6 +1,6 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.Fn1;
+import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
@@ -21,11 +21,11 @@ public interface Bifunctor<A, B> {
     /**
      * Covariantly map over the left parameter.
      *
-     * @param fn  the mapping function
      * @param <C> the new left parameter type
+     * @param fn  the mapping function
      * @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) {
+    default <C> Bifunctor<C, B> biMapL(Function<? super A, ? extends C> fn) {
         return biMap(fn, id());
     }
 
@@ -33,11 +33,11 @@ default <C> Bifunctor<C, B> biMapL(Fn1<? super A, ? 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
+     * @param fn  the mapping function
      * @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) {
+    default <C> Bifunctor<A, C> biMapR(Function<? super B, ? extends C> fn) {
         return biMap(id(), fn);
     }
 
@@ -45,11 +45,11 @@ default <C> Bifunctor<A, C> biMapR(Fn1<? super B, ? extends C> fn) {
      * 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
+     * @param lFn the left parameter mapping function
+     * @param rFn the right parameter mapping function
      * @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);
+    <C, D> Bifunctor<C, D> biMap(Function<? super A, ? extends C> lFn, Function<? 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 2d600d433..ef9b3b308 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Functor.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Functor.java
@@ -2,6 +2,8 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 
+import java.util.function.Function;
+
 /**
  * An interface for the generic covariant functorial operation <code>map</code> over some parameter <code>A</code>.
  * Functors are foundational to many of the classes provided by this library; generally, anything that can be thought of
@@ -23,9 +25,9 @@ public interface Functor<A> {
      * 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
+     * @param fn  the mapping function
      * @return a functor over B (the new parameter type)
      */
-    <B> Functor<B> fmap(Fn1<? super A, ? extends B> fn);
+    <B> Functor<B> fmap(Function<? 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 aae917e55..db8562172 100644
--- a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java
+++ b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java
@@ -2,6 +2,8 @@
 
 import com.jnape.palatable.lambda.functions.Fn1;
 
+import java.util.function.Function;
+
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
@@ -22,11 +24,11 @@ public interface Profunctor<A, B> {
     /**
      * Contravariantly map over the left parameter.
      *
-     * @param fn  the mapping function
      * @param <Z> the new left parameter type
+     * @param fn  the mapping function
      * @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) {
+    default <Z> Profunctor<Z, B> diMapL(Function<Z, A> fn) {
         return diMap(fn, id());
     }
 
@@ -34,11 +36,11 @@ default <Z> Profunctor<Z, B> diMapL(Fn1<Z, A> 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
+     * @param fn  the mapping function
      * @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) {
+    default <C> Profunctor<A, C> diMapR(Function<B, C> fn) {
         return diMap(id(), fn);
     }
 
@@ -46,11 +48,11 @@ default <C> Profunctor<A, C> diMapR(Fn1<B, C> fn) {
      * 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
+     * @param lFn the left parameter mapping function
+     * @param rFn the right parameter mapping function
      * @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);
+    <Z, C> Profunctor<Z, C> diMap(Function<Z, A> lFn, Function<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 093868e5e..b95f39eda 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,15 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn1;
-
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 
 public class FilteringIterator<A> extends ImmutableIterator<A> {
 
-    private final Fn1<? super A, Boolean> predicate;
-    private final RewindableIterator<A>   rewindableIterator;
+    private final Function<? super A, Boolean> predicate;
+    private final RewindableIterator<A>        rewindableIterator;
 
-    public FilteringIterator(Fn1<? super A, Boolean> predicate, Iterator<A> iterator) {
+    public FilteringIterator(Function<? 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 f950ee386..81b46c027 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,14 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn1;
-
 import java.util.Iterator;
+import java.util.function.Function;
 
 public class MappingIterator<A, B> extends ImmutableIterator<B> {
 
-    private final Fn1<? super A, ? extends B> function;
-    private final Iterator<A>                 iterator;
+    private final Function<? super A, ? extends B> function;
+    private final Iterator<A>                      iterator;
 
-    public MappingIterator(Fn1<? super A, ? extends B> function, Iterator<A> iterator) {
+    public MappingIterator(Function<? 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 02deacbf8..c7f8f279e 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,15 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn1;
-
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 
 public class PredicatedDroppingIterator<A> extends ImmutableIterator<A> {
-    private final Fn1<? super A, Boolean> predicate;
-    private final RewindableIterator<A>   rewindableIterator;
-    private       boolean                 finishedDropping;
+    private final Function<? super A, Boolean> predicate;
+    private final RewindableIterator<A>        rewindableIterator;
+    private       boolean                      finishedDropping;
 
-    public PredicatedDroppingIterator(Fn1<? super A, Boolean> predicate, Iterator<A> asIterator) {
+    public PredicatedDroppingIterator(Function<? 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 3fbcd5e17..c269ad72b 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,15 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn1;
-
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 
 public class PredicatedTakingIterator<A> extends ImmutableIterator<A> {
-    private final Fn1<? super A, Boolean> predicate;
-    private final RewindableIterator<A>   rewindableIterator;
-    private       boolean                 stillTaking;
+    private final Function<? super A, Boolean> predicate;
+    private final RewindableIterator<A>        rewindableIterator;
+    private       boolean                      stillTaking;
 
-    public PredicatedTakingIterator(Fn1<? super A, Boolean> predicate,
+    public PredicatedTakingIterator(Function<? 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/ScanningIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java
index 56e693629..aaaa43fb7 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,16 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn2;
-
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.function.BiFunction;
 
 public final class ScanningIterator<A, B> extends ImmutableIterator<B> {
 
-    private final Fn2<? super B, ? super A, ? extends B> scanner;
-    private final Iterator<A>                            asIterator;
-    private       B                                      b;
+    private final BiFunction<? super B, ? super A, ? extends B> scanner;
+    private final Iterator<A>                                   asIterator;
+    private       B                                             b;
 
-    public ScanningIterator(Fn2<? super B, ? super A, ? extends B> scanner, B b,
+    public ScanningIterator(BiFunction<? 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 896ca19dd..f329d146b 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.Fn1;
 
 import java.util.NoSuchElementException;
 import java.util.Optional;
+import java.util.function.Function;
 
 public class UnfoldingIterator<A, B> extends ImmutableIterator<A> {
-    private final Fn1<B, Optional<Tuple2<A, B>>> function;
-    private       Optional<Tuple2<A, B>>         optionalAcc;
+    private final Function<B, Optional<Tuple2<A, B>>> function;
+    private       Optional<Tuple2<A, B>>              optionalAcc;
 
-    public UnfoldingIterator(Fn1<B, Optional<Tuple2<A, B>>> function, B b) {
+    public UnfoldingIterator(Function<B, Optional<Tuple2<A, B>>> function, B b) {
         this.function = function;
         optionalAcc = function.apply(b);
     }
@@ -21,6 +21,7 @@ public boolean hasNext() {
     }
 
     @Override
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
     public A next() {
         if (!hasNext())
             throw new NoSuchElementException();
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 16d05c146..0372e6fff 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,14 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn2;
-
 import java.util.Iterator;
+import java.util.function.BiFunction;
 
 public class ZippingIterator<C, A, B> extends ImmutableIterator<C> {
-    private final Fn2<? super A, ? super B, ? extends C> zipper;
-    private final Iterator<A>                            asIterator;
-    private final Iterator<B>                            bsIterator;
+    private final BiFunction<? super A, ? super B, ? extends C> zipper;
+    private final Iterator<A>                                   asIterator;
+    private final Iterator<B>                                   bsIterator;
 
-    public ZippingIterator(Fn2<? super A, ? super B, ? extends C> zipper, Iterator<A> asIterator,
+    public ZippingIterator(BiFunction<? 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 21cd82655..634706372 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,5 @@
 package com.jnape.palatable.lambda.adt;
 
-import com.jnape.palatable.lambda.functions.Fn2;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -8,6 +7,7 @@
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiFunction;
 
 import static com.jnape.palatable.lambda.adt.Either.fromOptional;
 import static com.jnape.palatable.lambda.adt.Either.left;
@@ -98,8 +98,8 @@ public void mergeDuallyLiftsAndCombinesBiasingLeft() {
         Either<String, Integer> left2 = left("bar");
         Either<String, Integer> right2 = right(2);
 
-        Fn2<String, String, String> concat = String::concat;
-        Fn2<Integer, Integer, Integer> add = (r1, r2) -> r1 + r2;
+        BiFunction<String, String, String> concat = String::concat;
+        BiFunction<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/functions/Fn2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
index 12d62c4e2..49d7e9809 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
@@ -3,8 +3,11 @@
 import com.jnape.palatable.lambda.functions.builtin.fn1.Id;
 import org.junit.Test;
 
+import java.util.function.BiFunction;
+
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
 public class Fn2Test {
@@ -44,4 +47,10 @@ public void profunctorProperties() {
                 is("true")
         );
     }
+
+    @Test
+    public void toBiFunction() {
+        BiFunction<String, Integer, Boolean> biFunction = CHECK_LENGTH.toBiFunction();
+        assertEquals(true, biFunction.apply("abc", 3));
+    }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java
index e95465991..d746b0fc1 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java
@@ -7,6 +7,8 @@
 import org.junit.runner.RunWith;
 import testsupport.traits.EmptyIterableSupport;
 
+import java.util.function.Function;
+
 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;
@@ -17,7 +19,7 @@
 @RunWith(Traits.class)
 public class AllTest {
 
-    private static final Fn1<? super Number, Boolean> EVEN = x -> x.doubleValue() % 2 == 0;
+    private static final Function<? super Number, Boolean> EVEN = x -> x.doubleValue() % 2 == 0;
 
     @TestTraits({EmptyIterableSupport.class})
     public Fn1<Iterable<Object>, Boolean> createTestSubject() {
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java
index 8c5485d8c..aa8f8a118 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java
@@ -7,6 +7,8 @@
 import org.junit.runner.RunWith;
 import testsupport.traits.EmptyIterableSupport;
 
+import java.util.function.Function;
+
 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;
@@ -17,7 +19,7 @@
 @RunWith(Traits.class)
 public class AnyTest {
 
-    public static final Fn1<? super Integer, Boolean> EVEN = x -> x % 2 == 0;
+    public static final Function<? super Integer, Boolean> EVEN = x -> x % 2 == 0;
 
     @TestTraits({EmptyIterableSupport.class})
     public Fn1<Iterable<Object>, Boolean> createTestSubject() {
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
index 1e3a05a9a..81598f331 100644
--- 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
@@ -1,8 +1,9 @@
 package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.functions.Fn2;
 import org.junit.Test;
 
+import java.util.function.BiFunction;
+
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Partial2.partial2;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
@@ -11,8 +12,7 @@ public class Partial2Test {
 
     @Test
     public void partiallyAppliesFunction() {
-        Fn2<Integer, Integer, Integer> subtract = (minuend, subtrahend) -> minuend - subtrahend;
-
+        BiFunction<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/fn3/ZipWithTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java
index 0fcc085ad..ee1408417 100644
--- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java
@@ -2,7 +2,6 @@
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.Fn1;
-import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.runners.Traits;
 import org.junit.Test;
@@ -11,6 +10,8 @@
 import testsupport.traits.ImmutableIteration;
 import testsupport.traits.Laziness;
 
+import java.util.function.BiFunction;
+
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Zip.zip;
 import static com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith.zipWith;
@@ -31,7 +32,7 @@ public void zipsTwoIterablesTogetherWithFunction() {
         Iterable<Integer> oneThroughFive = asList(1, 2, 3, 4, 5);
         Iterable<Integer> sixThroughTen = asList(6, 7, 8, 9, 10);
 
-        Fn2<Integer, Integer, Integer> add = (a, b) -> a + b;
+        BiFunction<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/functor/BifunctorTest.java b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java
index 6d78c167d..afc3c0a8e 100644
--- a/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java
@@ -1,10 +1,10 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
 import testsupport.applicatives.InvocationRecordingBifunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 import static org.hamcrest.CoreMatchers.is;
@@ -14,7 +14,7 @@ public class BifunctorTest {
 
     @Test
     public void biMapLUsesIdentityForRightBiMapFunction() {
-        AtomicReference<Fn1> rightInvocation = new AtomicReference<>();
+        AtomicReference<Function> 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<Fn1> leftInvocation = new AtomicReference<>();
+        AtomicReference<Function> 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 63011de85..5e552f7e0 100644
--- a/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java
@@ -1,10 +1,10 @@
 package com.jnape.palatable.lambda.functor;
 
-import com.jnape.palatable.lambda.functions.Fn1;
 import org.junit.Test;
 import testsupport.applicatives.InvocationRecordingProfunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 import static org.hamcrest.CoreMatchers.is;
@@ -14,7 +14,7 @@ public class ProfunctorTest {
 
     @Test
     public void diMapLUsesIdentityForRightDiMapFunction() {
-        AtomicReference<Fn1> rightInvocation = new AtomicReference<>();
+        AtomicReference<Function> 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<Fn1> leftInvocation = new AtomicReference<>();
+        AtomicReference<Function> 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/ScanningIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
index b082925ab..387bc965e 100644
--- a/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
+++ b/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java
@@ -1,9 +1,9 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn2;
 import org.junit.Test;
 
 import java.util.NoSuchElementException;
+import java.util.function.BiFunction;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyIterator;
@@ -12,7 +12,7 @@
 
 public class ScanningIteratorTest {
 
-    public static final Fn2<Integer, Integer, Integer> ADD = (x, y) -> x + y;
+    public static final BiFunction<Integer, Integer, Integer> ADD = (x, y) -> x + y;
 
     @Test
     public void hasNextAtLeastForB() {
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 e80c53acd..561eb2534 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,5 @@
 package com.jnape.palatable.lambda.iterators;
 
-import com.jnape.palatable.lambda.functions.Fn2;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -8,6 +7,7 @@
 import org.mockito.runners.MockitoJUnitRunner;
 
 import java.util.Iterator;
+import java.util.function.BiFunction;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
@@ -17,9 +17,9 @@
 @RunWith(MockitoJUnitRunner.class)
 public class ZippingIteratorTest {
 
-    @Mock private Fn2<Object, Object, Object> zipper;
-    @Mock private Iterator<Object>            as;
-    @Mock private Iterator<Object>            bs;
+    @Mock private BiFunction<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 51b2fa24c..2ef23f622 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.Fn1;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 
 public final class InvocationRecordingBifunctor<A, B> implements Bifunctor<A, B> {
-    private final AtomicReference<Fn1> leftFn;
-    private final AtomicReference<Fn1> rightFn;
+    private final AtomicReference<Function> leftFn;
+    private final AtomicReference<Function> rightFn;
 
-    public InvocationRecordingBifunctor(AtomicReference<Fn1> leftFn,
-                                        AtomicReference<Fn1> rightFn) {
+    public InvocationRecordingBifunctor(AtomicReference<Function> leftFn,
+                                        AtomicReference<Function> rightFn) {
         this.leftFn = leftFn;
         this.rightFn = rightFn;
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <C, D> Bifunctor<C, D> biMap(Fn1<? super A, ? extends C> lFn,
-                                        Fn1<? super B, ? extends D> rFn) {
+    public <C, D> Bifunctor<C, D> biMap(Function<? super A, ? extends C> lFn,
+                                        Function<? 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 a5de7891b..dadcec960 100644
--- a/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java
+++ b/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java
@@ -1,23 +1,23 @@
 package testsupport.applicatives;
 
-import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.Profunctor;
 
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 
 public final class InvocationRecordingProfunctor<A, B> implements Profunctor<A, B> {
-    private final AtomicReference<Fn1> leftFn;
-    private final AtomicReference<Fn1> rightFn;
+    private final AtomicReference<Function> leftFn;
+    private final AtomicReference<Function> rightFn;
 
-    public InvocationRecordingProfunctor(AtomicReference<Fn1> leftFn,
-                                         AtomicReference<Fn1> rightFn) {
+    public InvocationRecordingProfunctor(AtomicReference<Function> leftFn,
+                                         AtomicReference<Function> rightFn) {
         this.leftFn = leftFn;
         this.rightFn = rightFn;
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <C, D> Profunctor<C, D> diMap(Fn1<C, A> lFn, Fn1<B, D> rFn) {
+    public <C, D> Profunctor<C, D> diMap(Function<C, A> lFn, Function<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 d59a2378b..a168674e3 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.Fn2;
+import java.util.function.BiFunction;
 
 import static java.lang.String.format;
 
 public class ExplainFold {
 
-    public static Fn2<String, String, String> explainFold() {
+    public static BiFunction<String, String, String> explainFold() {
         return (acc, x) -> format("(%s + %s)", acc, x);
     }
 }