From 0f9cd55bde0b09788ed918c5b53b05803fa98a12 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Sat, 26 Aug 2017 12:20:49 +0200
Subject: [PATCH 01/18] Add NonEmptyList#partitionE

---
 .../main/scala/cats/data/NonEmptyList.scala   | 14 +++++++++
 .../scala/cats/tests/NonEmptyListTests.scala  | 31 +++++++++++++++++++
 2 files changed, 45 insertions(+)

diff --git a/core/src/main/scala/cats/data/NonEmptyList.scala b/core/src/main/scala/cats/data/NonEmptyList.scala
index 3c86a0046f..95f30b32c7 100644
--- a/core/src/main/scala/cats/data/NonEmptyList.scala
+++ b/core/src/main/scala/cats/data/NonEmptyList.scala
@@ -343,6 +343,20 @@ final case class NonEmptyList[+A](head: A, tail: List[A]) {
     b.result
   }
 
+  def partitionE[B, C](f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
+    import cats.syntax.either._
+
+    val reversed = reverse
+    val lastIor = f(reversed.head).bimap(NonEmptyList.one, NonEmptyList.one).toIor
+
+    reversed.tail.foldLeft(lastIor)((ior, a) => (f(a), ior) match {
+      case (Right(c), Ior.Left(l)) => ior.putRight(NonEmptyList.one(c))
+      case (Right(c), _) => ior.map(c :: _)
+      case (Left(b), Ior.Right(r)) => Ior.bothNel(b, r)
+      case (Left(b), _) => ior.leftMap(b :: _)
+    })
+  }
+
 }
 
 object NonEmptyList extends NonEmptyListInstances {
diff --git a/tests/src/test/scala/cats/tests/NonEmptyListTests.scala b/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
index 4c6a4b5b17..bd0963a0bc 100644
--- a/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
+++ b/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
@@ -74,6 +74,37 @@ class NonEmptyListTests extends CatsSuite {
     }
   }
 
+  test("NonEmptyList#partitionE retains size") {
+    forAll { (nel: NonEmptyList[Int], f: Int => Either[String, String]) =>
+      val folded = nel.partitionE(f).fold(identity, identity, _ ++ _.toList)
+      folded.size should === (nel.size)
+    }
+  }
+
+  test("NonEmptyList#partitionE to one side is identity") {
+    forAll { (nel: NonEmptyList[Int], f: Int => String) =>
+      val g: Int => Either[Double, String] = f andThen Right.apply
+      val h: Int => Either[String, Double] = f andThen Left.apply
+
+      val withG = nel.partitionE(g).fold(_ => NonEmptyList.one(""), identity, (l,r) => r)
+      withG should === (nel.map(f))
+
+      val withH = nel.partitionE(h).fold(identity, _ => NonEmptyList.one(""), (l,r) => l)
+      withH should === (nel.map(f))
+    }
+  }
+
+  test("NonEmptyList#partitionE remains sorted") {
+    forAll { (nel: NonEmptyList[Int], f: Int => Either[String, String]) =>
+
+      val sorted = nel.map(f).sorted
+      val ior = sorted.partitionE(identity)
+
+      ior.left.map(xs => xs.sorted should === (xs))
+      ior.right.map(xs => xs.sorted should === (xs))
+    }
+  }
+
   test("NonEmptyList#filter is consistent with List#filter") {
     forAll { (nel: NonEmptyList[Int], p: Int => Boolean) =>
       val list = nel.toList

From 47048a9d6262139acda5d71c1f47dac570ca6303 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Tue, 29 Aug 2017 10:37:40 +0200
Subject: [PATCH 02/18] Generalize partitionE to Reducible

---
 core/src/main/scala/cats/Reducible.scala      | 19 ++++++++--
 .../main/scala/cats/data/NonEmptyList.scala   | 14 --------
 .../scala/cats/tests/NonEmptyListTests.scala  | 30 ----------------
 .../scala/cats/tests/ReducibleTests.scala     | 35 ++++++++++++++++++-
 4 files changed, 51 insertions(+), 47 deletions(-)

diff --git a/core/src/main/scala/cats/Reducible.scala b/core/src/main/scala/cats/Reducible.scala
index 348c037ca1..c5d0b555ee 100644
--- a/core/src/main/scala/cats/Reducible.scala
+++ b/core/src/main/scala/cats/Reducible.scala
@@ -1,7 +1,6 @@
 package cats
 
-import cats.data.NonEmptyList
-
+import cats.data.{Ior, NonEmptyList}
 import simulacrum.typeclass
 
 /**
@@ -177,6 +176,22 @@ import simulacrum.typeclass
         Reducible[NonEmptyList].reduce(NonEmptyList(hd, a :: intersperseList(tl, a)))
     }
 
+  def partitionE[A, B, C](fa: F[A])(f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
+    import cats.syntax.either._
+
+    def g(a: A, eval: Eval[Ior[NonEmptyList[B], NonEmptyList[C]]]): Eval[Ior[NonEmptyList[B], NonEmptyList[C]]] = {
+      val ior = eval.value
+      (f(a), ior) match {
+        case (Right(c), Ior.Left(_)) => Eval.now(ior.putRight(NonEmptyList.one(c)))
+        case (Right(c), _) => Eval.now(ior.map(c :: _))
+        case (Left(b), Ior.Right(r)) => Eval.now(Ior.bothNel(b, r))
+        case (Left(b), _) => Eval.now(ior.leftMap(b :: _))
+      }
+    }
+
+    reduceRightTo(fa)(a => f(a).bimap(NonEmptyList.one, NonEmptyList.one).toIor)(g).value
+  }
+
   override def isEmpty[A](fa: F[A]): Boolean = false
 
   override def nonEmpty[A](fa: F[A]): Boolean = true
diff --git a/core/src/main/scala/cats/data/NonEmptyList.scala b/core/src/main/scala/cats/data/NonEmptyList.scala
index 95f30b32c7..3c86a0046f 100644
--- a/core/src/main/scala/cats/data/NonEmptyList.scala
+++ b/core/src/main/scala/cats/data/NonEmptyList.scala
@@ -343,20 +343,6 @@ final case class NonEmptyList[+A](head: A, tail: List[A]) {
     b.result
   }
 
-  def partitionE[B, C](f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
-    import cats.syntax.either._
-
-    val reversed = reverse
-    val lastIor = f(reversed.head).bimap(NonEmptyList.one, NonEmptyList.one).toIor
-
-    reversed.tail.foldLeft(lastIor)((ior, a) => (f(a), ior) match {
-      case (Right(c), Ior.Left(l)) => ior.putRight(NonEmptyList.one(c))
-      case (Right(c), _) => ior.map(c :: _)
-      case (Left(b), Ior.Right(r)) => Ior.bothNel(b, r)
-      case (Left(b), _) => ior.leftMap(b :: _)
-    })
-  }
-
 }
 
 object NonEmptyList extends NonEmptyListInstances {
diff --git a/tests/src/test/scala/cats/tests/NonEmptyListTests.scala b/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
index bd0963a0bc..7abc1d1178 100644
--- a/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
+++ b/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
@@ -74,36 +74,6 @@ class NonEmptyListTests extends CatsSuite {
     }
   }
 
-  test("NonEmptyList#partitionE retains size") {
-    forAll { (nel: NonEmptyList[Int], f: Int => Either[String, String]) =>
-      val folded = nel.partitionE(f).fold(identity, identity, _ ++ _.toList)
-      folded.size should === (nel.size)
-    }
-  }
-
-  test("NonEmptyList#partitionE to one side is identity") {
-    forAll { (nel: NonEmptyList[Int], f: Int => String) =>
-      val g: Int => Either[Double, String] = f andThen Right.apply
-      val h: Int => Either[String, Double] = f andThen Left.apply
-
-      val withG = nel.partitionE(g).fold(_ => NonEmptyList.one(""), identity, (l,r) => r)
-      withG should === (nel.map(f))
-
-      val withH = nel.partitionE(h).fold(identity, _ => NonEmptyList.one(""), (l,r) => l)
-      withH should === (nel.map(f))
-    }
-  }
-
-  test("NonEmptyList#partitionE remains sorted") {
-    forAll { (nel: NonEmptyList[Int], f: Int => Either[String, String]) =>
-
-      val sorted = nel.map(f).sorted
-      val ior = sorted.partitionE(identity)
-
-      ior.left.map(xs => xs.sorted should === (xs))
-      ior.right.map(xs => xs.sorted should === (xs))
-    }
-  }
 
   test("NonEmptyList#filter is consistent with List#filter") {
     forAll { (nel: NonEmptyList[Int], p: Int => Boolean) =>
diff --git a/tests/src/test/scala/cats/tests/ReducibleTests.scala b/tests/src/test/scala/cats/tests/ReducibleTests.scala
index 8f6230a82e..1a8a1163c4 100644
--- a/tests/src/test/scala/cats/tests/ReducibleTests.scala
+++ b/tests/src/test/scala/cats/tests/ReducibleTests.scala
@@ -71,7 +71,7 @@ class ReducibleTestsAdditional extends CatsSuite {
 
 }
 
-abstract class ReducibleCheck[F[_]: Reducible](name: String)(implicit ArbFInt: Arbitrary[F[Int]], ArbFString: Arbitrary[F[String]]) extends FoldableCheck[F](name) {
+abstract class ReducibleCheck[F[_]: Reducible: Functor](name: String)(implicit ArbFInt: Arbitrary[F[Int]], ArbFString: Arbitrary[F[String]]) extends FoldableCheck[F](name) {
   def range(start: Long, endInclusive: Long): F[Long]
 
   test(s"Reducible[$name].reduceLeftM stack safety") {
@@ -95,4 +95,37 @@ abstract class ReducibleCheck[F[_]: Reducible](name: String)(implicit ArbFInt: A
       fa.nonEmptyIntercalate(a) === (fa.toList.mkString(a))
     }
   }
+
+
+  test("Reducible#partitionE retains size") {
+    forAll { (fi: F[Int], f: Int => Either[String, String]) =>
+      val folded = fi.partitionE(f).fold(identity, identity, _ ++ _.toList)
+      folded.size.toLong should === (fi.size)
+    }
+  }
+
+  test("Reducible#partitionE to one side is identity") {
+    forAll { (fi: F[Int], f: Int => String) =>
+      val g: Int => Either[Double, String] = f andThen Right.apply
+      val h: Int => Either[String, Double] = f andThen Left.apply
+
+      val withG = fi.partitionE(g).fold(_ => NonEmptyList.one(""), identity, (l,r) => r)
+      withG should === (Reducible[F].toNonEmptyList((fi.map(f))))
+
+      val withH = fi.partitionE(h).fold(identity, _ => NonEmptyList.one(""), (l,r) => l)
+      withH should === (Reducible[F].toNonEmptyList((fi.map(f))))
+    }
+  }
+
+  test("Reducible#partitionE remains sorted") {
+    forAll { (fi: F[Int], f: Int => Either[String, String]) =>
+      val nel = Reducible[F].toNonEmptyList(fi)
+
+      val sorted = nel.map(f).sorted
+      val ior = sorted.partitionE(identity)
+
+      ior.left.map(xs => xs.sorted should === (xs))
+      ior.right.map(xs => xs.sorted should === (xs))
+    }
+  }
 }

From 3de168addcc833873e662d838aa036a98b48aec7 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Tue, 29 Aug 2017 18:15:02 +0200
Subject: [PATCH 03/18] Add doctest

---
 core/src/main/scala/cats/Reducible.scala | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/core/src/main/scala/cats/Reducible.scala b/core/src/main/scala/cats/Reducible.scala
index c5d0b555ee..688193ae20 100644
--- a/core/src/main/scala/cats/Reducible.scala
+++ b/core/src/main/scala/cats/Reducible.scala
@@ -176,6 +176,19 @@ import simulacrum.typeclass
         Reducible[NonEmptyList].reduce(NonEmptyList(hd, a :: intersperseList(tl, a)))
     }
 
+  /**
+    * Partition this Reducible by a separating function `A => Either[B, C]
+    *
+    * {{{
+    * scala> import cats.implicits._
+    * scala> import cats.data.NonEmptyList
+    * scala> val nel = NonEmptyList.of(1,2,3,4)
+    * scala> Reducible[NonEmptyList].partitionE(nel)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
+    * res0: cats.data.Ior[cats.data.NonEmptyList[String],cats.data.NonEmptyList[Int]] = Both(NonEmptyList(2, 4),NonEmptyList(1, 3))
+    * scala> Reducible[NonEmptyList].partitionE(nel)(a => Right(a * 4))
+    * res1: cats.data.Ior[cats.data.NonEmptyList[Nothing],cats.data.NonEmptyList[Int]] = Right(NonEmptyList(4, 8, 12, 16))
+    * }}}
+    */
   def partitionE[A, B, C](fa: F[A])(f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
     import cats.syntax.either._
 

From a5cbeeed0a00b96a88cdd58afd434447c89ee8ba Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Tue, 29 Aug 2017 18:18:59 +0200
Subject: [PATCH 04/18] Add mapSeparate

---
 core/src/main/scala/cats/Alternative.scala | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/core/src/main/scala/cats/Alternative.scala b/core/src/main/scala/cats/Alternative.scala
index def09bb1bf..b0d9aa4601 100644
--- a/core/src/main/scala/cats/Alternative.scala
+++ b/core/src/main/scala/cats/Alternative.scala
@@ -22,6 +22,18 @@ import simulacrum.typeclass
     (as, bs)
   }
 
+  def mapSeparate[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit F: Foldable[F], A: Alternative[F]): (F[B], F[C]) = {
+    import cats.instances.tuple._
+
+    implicit val mb: Monoid[F[B]] = Alternative[F].algebra[B]
+    implicit val mc: Monoid[F[C]] = Alternative[F].algebra[C]
+
+    F.foldMap(fa)(a => f(a) match {
+      case Right(c) => (empty[B], pure(c))
+      case Left(b) => (pure(b), empty[C])
+    })
+  }
+
   override def compose[G[_]: Applicative]: Alternative[λ[α => F[G[α]]]] =
     new ComposedAlternative[F, G] {
       val F = self

From e4029ab769b2a9f82b74412a12807f83123c415e Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Tue, 29 Aug 2017 22:26:17 +0200
Subject: [PATCH 05/18] Fix nitpick

---
 core/src/main/scala/cats/Alternative.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/scala/cats/Alternative.scala b/core/src/main/scala/cats/Alternative.scala
index b0d9aa4601..0e1cc340c4 100644
--- a/core/src/main/scala/cats/Alternative.scala
+++ b/core/src/main/scala/cats/Alternative.scala
@@ -25,8 +25,8 @@ import simulacrum.typeclass
   def mapSeparate[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit F: Foldable[F], A: Alternative[F]): (F[B], F[C]) = {
     import cats.instances.tuple._
 
-    implicit val mb: Monoid[F[B]] = Alternative[F].algebra[B]
-    implicit val mc: Monoid[F[C]] = Alternative[F].algebra[C]
+    implicit val mb: Monoid[F[B]] = A.algebra[B]
+    implicit val mc: Monoid[F[C]] = A.algebra[C]
 
     F.foldMap(fa)(a => f(a) match {
       case Right(c) => (empty[B], pure(c))

From 0a7ac7052cfa2016b7fc942a50b7447c02c4e52c Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 09:18:12 +0200
Subject: [PATCH 06/18] Add Scaladoc and tests for mapSeparate

---
 core/src/main/scala/cats/Alternative.scala    |  3 ++
 core/src/main/scala/cats/Reducible.scala      |  3 +-
 .../test/scala/cats/tests/FoldableTests.scala | 34 +++++++++++++++++++
 3 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/core/src/main/scala/cats/Alternative.scala b/core/src/main/scala/cats/Alternative.scala
index 0e1cc340c4..dfdacf033e 100644
--- a/core/src/main/scala/cats/Alternative.scala
+++ b/core/src/main/scala/cats/Alternative.scala
@@ -22,6 +22,9 @@ import simulacrum.typeclass
     (as, bs)
   }
 
+  /**
+    * Separate this Foldable into a Tuple by a separating function `A => Either[B, C]`
+    */
   def mapSeparate[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit F: Foldable[F], A: Alternative[F]): (F[B], F[C]) = {
     import cats.instances.tuple._
 
diff --git a/core/src/main/scala/cats/Reducible.scala b/core/src/main/scala/cats/Reducible.scala
index 688193ae20..d0906f7f01 100644
--- a/core/src/main/scala/cats/Reducible.scala
+++ b/core/src/main/scala/cats/Reducible.scala
@@ -177,10 +177,9 @@ import simulacrum.typeclass
     }
 
   /**
-    * Partition this Reducible by a separating function `A => Either[B, C]
+    * Partition this Reducible by a separating function `A => Either[B, C]`
     *
     * {{{
-    * scala> import cats.implicits._
     * scala> import cats.data.NonEmptyList
     * scala> val nel = NonEmptyList.of(1,2,3,4)
     * scala> Reducible[NonEmptyList].partitionE(nel)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
diff --git a/tests/src/test/scala/cats/tests/FoldableTests.scala b/tests/src/test/scala/cats/tests/FoldableTests.scala
index c5d84cdb22..5bf73b0674 100644
--- a/tests/src/test/scala/cats/tests/FoldableTests.scala
+++ b/tests/src/test/scala/cats/tests/FoldableTests.scala
@@ -25,6 +25,40 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
+  test("Alternative#mapSeparate retains size") {
+    forAll { (fi: F[Int], f: Int => Either[String, String]) =>
+      val list = Foldable[F].toList(fi)
+      val (lefts, rights) = Alternative[List].mapSeparate(list)(f)
+      (lefts <+> rights).size.toLong should === (fi.size)
+    }
+  }
+
+  test("Alternative#mapSeparate to one side is identity") {
+    forAll { (fi: F[Int], f: Int => String) =>
+      val list = Foldable[F].toList(fi)
+      val g: Int => Either[Double, String] = f andThen Right.apply
+      val h: Int => Either[String, Double] = f andThen Left.apply
+
+      val withG = Alternative[List].mapSeparate(list)(g)._2
+      withG should === (list.map(f))
+
+      val withH = Alternative[List].mapSeparate(list)(h)._1
+      withH should === (list.map(f))
+    }
+  }
+
+  test("Alternative#mapSeparate remains sorted") {
+    forAll { (fi: F[Int], f: Int => Either[String, String]) =>
+      val list = Foldable[F].toList(fi)
+
+      val sorted = list.map(f).sorted
+      val (lefts, rights) = Alternative[List].mapSeparate(sorted)(identity)
+
+      lefts.sorted should === (lefts)
+      rights.sorted should === (rights)
+    }
+  }
+
   test(s"Foldable[$name] summation") {
     forAll { (fa: F[Int]) =>
       val total = iterator(fa).sum

From dbd636e8d89791596a39119118cbd4872d6736d4 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 16:00:54 +0200
Subject: [PATCH 07/18] Simplify

---
 core/src/main/scala/cats/Reducible.scala             | 12 ++++++------
 tests/src/test/scala/cats/tests/ReducibleTests.scala | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/core/src/main/scala/cats/Reducible.scala b/core/src/main/scala/cats/Reducible.scala
index d0906f7f01..bf2f184689 100644
--- a/core/src/main/scala/cats/Reducible.scala
+++ b/core/src/main/scala/cats/Reducible.scala
@@ -192,13 +192,13 @@ import simulacrum.typeclass
     import cats.syntax.either._
 
     def g(a: A, eval: Eval[Ior[NonEmptyList[B], NonEmptyList[C]]]): Eval[Ior[NonEmptyList[B], NonEmptyList[C]]] = {
-      val ior = eval.value
+      eval.map(ior =>
       (f(a), ior) match {
-        case (Right(c), Ior.Left(_)) => Eval.now(ior.putRight(NonEmptyList.one(c)))
-        case (Right(c), _) => Eval.now(ior.map(c :: _))
-        case (Left(b), Ior.Right(r)) => Eval.now(Ior.bothNel(b, r))
-        case (Left(b), _) => Eval.now(ior.leftMap(b :: _))
-      }
+        case (Right(c), Ior.Left(_)) => ior.putRight(NonEmptyList.one(c))
+        case (Right(c), _) => ior.map(c :: _)
+        case (Left(b), Ior.Right(r)) => Ior.bothNel(b, r)
+        case (Left(b), _) => ior.leftMap(b :: _)
+      })
     }
 
     reduceRightTo(fa)(a => f(a).bimap(NonEmptyList.one, NonEmptyList.one).toIor)(g).value
diff --git a/tests/src/test/scala/cats/tests/ReducibleTests.scala b/tests/src/test/scala/cats/tests/ReducibleTests.scala
index 1a8a1163c4..2e527e651d 100644
--- a/tests/src/test/scala/cats/tests/ReducibleTests.scala
+++ b/tests/src/test/scala/cats/tests/ReducibleTests.scala
@@ -71,7 +71,7 @@ class ReducibleTestsAdditional extends CatsSuite {
 
 }
 
-abstract class ReducibleCheck[F[_]: Reducible: Functor](name: String)(implicit ArbFInt: Arbitrary[F[Int]], ArbFString: Arbitrary[F[String]]) extends FoldableCheck[F](name) {
+abstract class ReducibleCheck[F[_]: Reducible](name: String)(implicit ArbFInt: Arbitrary[F[Int]], ArbFString: Arbitrary[F[String]]) extends FoldableCheck[F](name) {
   def range(start: Long, endInclusive: Long): F[Long]
 
   test(s"Reducible[$name].reduceLeftM stack safety") {
@@ -109,11 +109,11 @@ abstract class ReducibleCheck[F[_]: Reducible: Functor](name: String)(implicit A
       val g: Int => Either[Double, String] = f andThen Right.apply
       val h: Int => Either[String, Double] = f andThen Left.apply
 
-      val withG = fi.partitionE(g).fold(_ => NonEmptyList.one(""), identity, (l,r) => r)
-      withG should === (Reducible[F].toNonEmptyList((fi.map(f))))
+      val withG = fi.partitionE(g).right.getOrElse(NonEmptyList.one(""))
+      withG should === (Reducible[F].toNonEmptyList(fi).map(f))
 
-      val withH = fi.partitionE(h).fold(identity, _ => NonEmptyList.one(""), (l,r) => l)
-      withH should === (Reducible[F].toNonEmptyList((fi.map(f))))
+      val withH = fi.partitionE(h).left.getOrElse(NonEmptyList.one(""))
+      withH should === (Reducible[F].toNonEmptyList(fi).map(f))
     }
   }
 

From 120ee7660c2f860c760d3fc3729eab6292c591b6 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 16:34:29 +0200
Subject: [PATCH 08/18] Rename operations

---
 core/src/main/scala/cats/Alternative.scala        | 15 ---------------
 core/src/main/scala/cats/Foldable.scala           | 15 +++++++++++++++
 core/src/main/scala/cats/Reducible.scala          |  6 +++---
 .../src/test/scala/cats/tests/FoldableTests.scala | 12 ++++++------
 .../test/scala/cats/tests/ReducibleTests.scala    | 14 +++++++-------
 5 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/core/src/main/scala/cats/Alternative.scala b/core/src/main/scala/cats/Alternative.scala
index dfdacf033e..def09bb1bf 100644
--- a/core/src/main/scala/cats/Alternative.scala
+++ b/core/src/main/scala/cats/Alternative.scala
@@ -22,21 +22,6 @@ import simulacrum.typeclass
     (as, bs)
   }
 
-  /**
-    * Separate this Foldable into a Tuple by a separating function `A => Either[B, C]`
-    */
-  def mapSeparate[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit F: Foldable[F], A: Alternative[F]): (F[B], F[C]) = {
-    import cats.instances.tuple._
-
-    implicit val mb: Monoid[F[B]] = A.algebra[B]
-    implicit val mc: Monoid[F[C]] = A.algebra[C]
-
-    F.foldMap(fa)(a => f(a) match {
-      case Right(c) => (empty[B], pure(c))
-      case Left(b) => (pure(b), empty[C])
-    })
-  }
-
   override def compose[G[_]: Applicative]: Alternative[λ[α => F[G[α]]]] =
     new ComposedAlternative[F, G] {
       val F = self
diff --git a/core/src/main/scala/cats/Foldable.scala b/core/src/main/scala/cats/Foldable.scala
index 838cad03fa..a4029b583a 100644
--- a/core/src/main/scala/cats/Foldable.scala
+++ b/core/src/main/scala/cats/Foldable.scala
@@ -406,6 +406,21 @@ import simulacrum.typeclass
       buf += a
     }.toList
 
+  /**
+    * Separate this Foldable into a Tuple by a separating function `A => Either[B, C]`
+    */
+  def partitionEither[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit F: Foldable[F], A: Alternative[F]): (F[B], F[C]) = {
+    import cats.instances.tuple._
+
+    implicit val mb: Monoid[F[B]] = A.algebra[B]
+    implicit val mc: Monoid[F[C]] = A.algebra[C]
+
+    F.foldMap(fa)(a => f(a) match {
+      case Right(c) => (A.empty[B], A.pure(c))
+      case Left(b) => (A.pure(b), A.empty[C])
+    })
+  }
+
   /**
    * Convert F[A] to a List[A], only including elements which match `p`.
    */
diff --git a/core/src/main/scala/cats/Reducible.scala b/core/src/main/scala/cats/Reducible.scala
index bf2f184689..d8556b0cb7 100644
--- a/core/src/main/scala/cats/Reducible.scala
+++ b/core/src/main/scala/cats/Reducible.scala
@@ -182,13 +182,13 @@ import simulacrum.typeclass
     * {{{
     * scala> import cats.data.NonEmptyList
     * scala> val nel = NonEmptyList.of(1,2,3,4)
-    * scala> Reducible[NonEmptyList].partitionE(nel)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
+    * scala> Reducible[NonEmptyList].nonEmptyPartition(nel)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
     * res0: cats.data.Ior[cats.data.NonEmptyList[String],cats.data.NonEmptyList[Int]] = Both(NonEmptyList(2, 4),NonEmptyList(1, 3))
-    * scala> Reducible[NonEmptyList].partitionE(nel)(a => Right(a * 4))
+    * scala> Reducible[NonEmptyList].nonEmptyPartition(nel)(a => Right(a * 4))
     * res1: cats.data.Ior[cats.data.NonEmptyList[Nothing],cats.data.NonEmptyList[Int]] = Right(NonEmptyList(4, 8, 12, 16))
     * }}}
     */
-  def partitionE[A, B, C](fa: F[A])(f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
+  def nonEmptyPartition[A, B, C](fa: F[A])(f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
     import cats.syntax.either._
 
     def g(a: A, eval: Eval[Ior[NonEmptyList[B], NonEmptyList[C]]]): Eval[Ior[NonEmptyList[B], NonEmptyList[C]]] = {
diff --git a/tests/src/test/scala/cats/tests/FoldableTests.scala b/tests/src/test/scala/cats/tests/FoldableTests.scala
index 5bf73b0674..694f8d6a33 100644
--- a/tests/src/test/scala/cats/tests/FoldableTests.scala
+++ b/tests/src/test/scala/cats/tests/FoldableTests.scala
@@ -25,24 +25,24 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
-  test("Alternative#mapSeparate retains size") {
+  test("Alternative#partitionEither retains size") {
     forAll { (fi: F[Int], f: Int => Either[String, String]) =>
       val list = Foldable[F].toList(fi)
-      val (lefts, rights) = Alternative[List].mapSeparate(list)(f)
+      val (lefts, rights) = Foldable[List].partitionEither(list)(f)
       (lefts <+> rights).size.toLong should === (fi.size)
     }
   }
 
-  test("Alternative#mapSeparate to one side is identity") {
+  test("Alternative#partitionEither to one side is identity") {
     forAll { (fi: F[Int], f: Int => String) =>
       val list = Foldable[F].toList(fi)
       val g: Int => Either[Double, String] = f andThen Right.apply
       val h: Int => Either[String, Double] = f andThen Left.apply
 
-      val withG = Alternative[List].mapSeparate(list)(g)._2
+      val withG = Foldable[List].partitionEither(list)(g)._2
       withG should === (list.map(f))
 
-      val withH = Alternative[List].mapSeparate(list)(h)._1
+      val withH = Foldable[List].partitionEither(list)(h)._1
       withH should === (list.map(f))
     }
   }
@@ -52,7 +52,7 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
       val list = Foldable[F].toList(fi)
 
       val sorted = list.map(f).sorted
-      val (lefts, rights) = Alternative[List].mapSeparate(sorted)(identity)
+      val (lefts, rights) = Foldable[List].partitionEither(sorted)(identity)
 
       lefts.sorted should === (lefts)
       rights.sorted should === (rights)
diff --git a/tests/src/test/scala/cats/tests/ReducibleTests.scala b/tests/src/test/scala/cats/tests/ReducibleTests.scala
index 2e527e651d..b3585bd9bb 100644
--- a/tests/src/test/scala/cats/tests/ReducibleTests.scala
+++ b/tests/src/test/scala/cats/tests/ReducibleTests.scala
@@ -97,32 +97,32 @@ abstract class ReducibleCheck[F[_]: Reducible](name: String)(implicit ArbFInt: A
   }
 
 
-  test("Reducible#partitionE retains size") {
+  test("Reducible#nonEmptyPartition retains size") {
     forAll { (fi: F[Int], f: Int => Either[String, String]) =>
-      val folded = fi.partitionE(f).fold(identity, identity, _ ++ _.toList)
+      val folded = fi.nonEmptyPartition(f).fold(identity, identity, _ ++ _.toList)
       folded.size.toLong should === (fi.size)
     }
   }
 
-  test("Reducible#partitionE to one side is identity") {
+  test("Reducible#nonEmptyPartition to one side is identity") {
     forAll { (fi: F[Int], f: Int => String) =>
       val g: Int => Either[Double, String] = f andThen Right.apply
       val h: Int => Either[String, Double] = f andThen Left.apply
 
-      val withG = fi.partitionE(g).right.getOrElse(NonEmptyList.one(""))
+      val withG = fi.nonEmptyPartition(g).right.getOrElse(NonEmptyList.one(""))
       withG should === (Reducible[F].toNonEmptyList(fi).map(f))
 
-      val withH = fi.partitionE(h).left.getOrElse(NonEmptyList.one(""))
+      val withH = fi.nonEmptyPartition(h).left.getOrElse(NonEmptyList.one(""))
       withH should === (Reducible[F].toNonEmptyList(fi).map(f))
     }
   }
 
-  test("Reducible#partitionE remains sorted") {
+  test("Reducible#nonEmptyPartition remains sorted") {
     forAll { (fi: F[Int], f: Int => Either[String, String]) =>
       val nel = Reducible[F].toNonEmptyList(fi)
 
       val sorted = nel.map(f).sorted
-      val ior = sorted.partitionE(identity)
+      val ior = sorted.nonEmptyPartition(identity)
 
       ior.left.map(xs => xs.sorted should === (xs))
       ior.right.map(xs => xs.sorted should === (xs))

From 9949687e3bafed3009dba229e4c6503cb7ac7657 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 16:43:58 +0200
Subject: [PATCH 09/18] Rename test titles as well

---
 tests/src/test/scala/cats/tests/FoldableTests.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/src/test/scala/cats/tests/FoldableTests.scala b/tests/src/test/scala/cats/tests/FoldableTests.scala
index 694f8d6a33..233e94ef1c 100644
--- a/tests/src/test/scala/cats/tests/FoldableTests.scala
+++ b/tests/src/test/scala/cats/tests/FoldableTests.scala
@@ -25,7 +25,7 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
-  test("Alternative#partitionEither retains size") {
+  test("Foldable#partitionEither retains size") {
     forAll { (fi: F[Int], f: Int => Either[String, String]) =>
       val list = Foldable[F].toList(fi)
       val (lefts, rights) = Foldable[List].partitionEither(list)(f)
@@ -33,7 +33,7 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
-  test("Alternative#partitionEither to one side is identity") {
+  test("Foldable#partitionEither to one side is identity") {
     forAll { (fi: F[Int], f: Int => String) =>
       val list = Foldable[F].toList(fi)
       val g: Int => Either[Double, String] = f andThen Right.apply
@@ -47,7 +47,7 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
-  test("Alternative#mapSeparate remains sorted") {
+  test("Foldable#mapSeparate remains sorted") {
     forAll { (fi: F[Int], f: Int => Either[String, String]) =>
       val list = Foldable[F].toList(fi)
 

From f3169aa9f52c6ca198796bd0fcf419f6a556e890 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 16:45:56 +0200
Subject: [PATCH 10/18] Remove redundant Foldable constraint

---
 core/src/main/scala/cats/Foldable.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/scala/cats/Foldable.scala b/core/src/main/scala/cats/Foldable.scala
index a4029b583a..9d94468ce5 100644
--- a/core/src/main/scala/cats/Foldable.scala
+++ b/core/src/main/scala/cats/Foldable.scala
@@ -409,13 +409,13 @@ import simulacrum.typeclass
   /**
     * Separate this Foldable into a Tuple by a separating function `A => Either[B, C]`
     */
-  def partitionEither[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit F: Foldable[F], A: Alternative[F]): (F[B], F[C]) = {
+  def partitionEither[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit A: Alternative[F]): (F[B], F[C]) = {
     import cats.instances.tuple._
 
     implicit val mb: Monoid[F[B]] = A.algebra[B]
     implicit val mc: Monoid[F[C]] = A.algebra[C]
 
-    F.foldMap(fa)(a => f(a) match {
+    foldMap(fa)(a => f(a) match {
       case Right(c) => (A.empty[B], A.pure(c))
       case Left(b) => (A.pure(b), A.empty[C])
     })

From 3c069d293faf32c522d4937c1651bef95cd65b59 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 17:13:42 +0200
Subject: [PATCH 11/18] Add doc tests and note in docs for map + separate

---
 core/src/main/scala/cats/Foldable.scala | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/core/src/main/scala/cats/Foldable.scala b/core/src/main/scala/cats/Foldable.scala
index 9d94468ce5..16749333d0 100644
--- a/core/src/main/scala/cats/Foldable.scala
+++ b/core/src/main/scala/cats/Foldable.scala
@@ -408,6 +408,16 @@ import simulacrum.typeclass
 
   /**
     * Separate this Foldable into a Tuple by a separating function `A => Either[B, C]`
+    * Equivalent to `Functor#map` and then `Alternative#separate`.
+    *
+    * {{{
+    * scala> import cats.implicits._
+    * scala> val list = List(1,2,3,4)
+    * scala> Foldable[List].partitionEither(list)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
+    * res0: (List[String], List[Int]) = (List(2, 4),List(1, 3))
+    * scala> Foldable[List].partitionEither(list)(a => Right(a * 4))
+    * res1: (List[Nothing], List[Int]) = (List(),List(4, 8, 12, 16))
+    * }}}
     */
   def partitionEither[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit A: Alternative[F]): (F[B], F[C]) = {
     import cats.instances.tuple._

From 98dfc73a7ed9c65521c8b0196a7ced387ffd49b8 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 22:15:38 +0200
Subject: [PATCH 12/18] Forgot to rename

---
 tests/src/test/scala/cats/tests/FoldableTests.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/src/test/scala/cats/tests/FoldableTests.scala b/tests/src/test/scala/cats/tests/FoldableTests.scala
index 233e94ef1c..e37e53dc37 100644
--- a/tests/src/test/scala/cats/tests/FoldableTests.scala
+++ b/tests/src/test/scala/cats/tests/FoldableTests.scala
@@ -47,7 +47,7 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
-  test("Foldable#mapSeparate remains sorted") {
+  test("Foldable#partitionEither remains sorted") {
     forAll { (fi: F[Int], f: Int => Either[String, String]) =>
       val list = Foldable[F].toList(fi)
 

From fc825c480e1307d2aaa389ba999cb39edc45ac76 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 30 Aug 2017 22:38:43 +0200
Subject: [PATCH 13/18] Add test checking if partitionEither is consistent with
 List#partition

---
 .../src/test/scala/cats/tests/FoldableTests.scala  | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/tests/src/test/scala/cats/tests/FoldableTests.scala b/tests/src/test/scala/cats/tests/FoldableTests.scala
index e37e53dc37..3bf114fe13 100644
--- a/tests/src/test/scala/cats/tests/FoldableTests.scala
+++ b/tests/src/test/scala/cats/tests/FoldableTests.scala
@@ -33,6 +33,20 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
     }
   }
 
+  test("Foldable#partitionEither consistent with List#partition") {
+    forAll { (fi: F[Int], f: Int => Either[String, String]) =>
+      val list = Foldable[F].toList(fi)
+      val (lefts, rights) = Foldable[List].partitionEither(list)(f)
+      val (ls, rs) = list.map(f).partition({
+        case Left(_) => true
+        case Right(_) => false
+      })
+
+      lefts.map(_.asLeft[String]) should === (ls)
+      rights.map(_.asRight[String]) should === (rs)
+    }
+  }
+
   test("Foldable#partitionEither to one side is identity") {
     forAll { (fi: F[Int], f: Int => String) =>
       val list = Foldable[F].toList(fi)

From 202abbcc41854156ebdb1811acbf7a22e9d74030 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Sun, 3 Sep 2017 19:21:33 +0200
Subject: [PATCH 14/18] Override Foldable[List].partitionEither for performance

---
 core/src/main/scala/cats/instances/list.scala | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/core/src/main/scala/cats/instances/list.scala b/core/src/main/scala/cats/instances/list.scala
index 431e6f6d87..0868f3dcba 100644
--- a/core/src/main/scala/cats/instances/list.scala
+++ b/core/src/main/scala/cats/instances/list.scala
@@ -76,6 +76,14 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
       override def zipWithIndex[A](fa: List[A]): List[(A, Int)] =
         fa.zipWithIndex
 
+      override def partitionEither[A, B, C](fa: List[A])
+                                           (f: (A) => Either[B, C])
+                                           (implicit A: Alternative[List]): (List[B], List[C]) =
+        fa.foldRight(List.empty[B], List.empty[C])((a, acc) => f(a) match {
+          case Left(b) => (b :: acc._1, acc._2)
+          case Right(c) => (acc._1, c :: acc._2)
+        })
+
       @tailrec
       override def get[A](fa: List[A])(idx: Long): Option[A] =
         fa match {

From 49891e1328a2a830044bb945eb9766c78e34c8d5 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Tue, 5 Sep 2017 22:55:33 +0200
Subject: [PATCH 15/18] add more efficient overloads

---
 .../src/main/scala/cats/data/NonEmptyList.scala | 17 +++++++++++++++++
 .../main/scala/cats/data/NonEmptyVector.scala   | 13 +++++++++++++
 core/src/main/scala/cats/instances/list.scala   |  2 +-
 3 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/core/src/main/scala/cats/data/NonEmptyList.scala b/core/src/main/scala/cats/data/NonEmptyList.scala
index 3c86a0046f..4a84da2944 100644
--- a/core/src/main/scala/cats/data/NonEmptyList.scala
+++ b/core/src/main/scala/cats/data/NonEmptyList.scala
@@ -452,6 +452,23 @@ private[data] sealed trait NonEmptyListInstances extends NonEmptyListInstances0
       override def fold[A](fa: NonEmptyList[A])(implicit A: Monoid[A]): A =
         fa.reduce
 
+      override def nonEmptyPartition[A, B, C](fa: NonEmptyList[A])
+                                             (f: (A) => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
+        import cats.syntax.either._
+
+        val reversed = fa.reverse
+        val lastIor = f(reversed.head).bimap(NonEmptyList.one, NonEmptyList.one).toIor
+
+        reversed.tail.foldLeft(lastIor)((ior, a) => (f(a), ior) match {
+          case (Right(c), Ior.Left(_)) => ior.putRight(NonEmptyList.one(c))
+          case (Right(c), _) => ior.map(c :: _)
+          case (Left(b), Ior.Right(r)) => Ior.bothNel(b, r)
+          case (Left(b), _) => ior.leftMap(b :: _)
+        })
+
+      }
+
+
       override def find[A](fa: NonEmptyList[A])(f: A => Boolean): Option[A] =
         fa find f
 
diff --git a/core/src/main/scala/cats/data/NonEmptyVector.scala b/core/src/main/scala/cats/data/NonEmptyVector.scala
index 292d7252ac..fda9c0af09 100644
--- a/core/src/main/scala/cats/data/NonEmptyVector.scala
+++ b/core/src/main/scala/cats/data/NonEmptyVector.scala
@@ -257,6 +257,19 @@ private[data] sealed trait NonEmptyVectorInstances {
       override def foldRight[A, B](fa: NonEmptyVector[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
         fa.foldRight(lb)(f)
 
+      override def nonEmptyPartition[A, B, C](fa: NonEmptyVector[A])(f: (A) => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
+        import cats.syntax.reducible._
+        import cats.syntax.either._
+
+        fa.reduceLeftTo(a => f(a).bimap(NonEmptyVector.one, NonEmptyVector.one).toIor)((ior, a) => (f(a), ior) match {
+          case (Right(c), Ior.Left(_)) => ior.putRight(NonEmptyVector.one(c))
+          case (Right(c), _) => ior.map(_ :+ c)
+          case (Left(b), Ior.Right(_)) => ior.putLeft(NonEmptyVector.one(b))
+          case (Left(b), _) => ior.leftMap(_ :+ b)
+        }).bimap(_.toNonEmptyList, _.toNonEmptyList)
+
+      }
+
       override def get[A](fa: NonEmptyVector[A])(idx: Long): Option[A] =
         if (0 <= idx && idx < Int.MaxValue) fa.get(idx.toInt) else None
 
diff --git a/core/src/main/scala/cats/instances/list.scala b/core/src/main/scala/cats/instances/list.scala
index 0868f3dcba..b0b2178bce 100644
--- a/core/src/main/scala/cats/instances/list.scala
+++ b/core/src/main/scala/cats/instances/list.scala
@@ -79,7 +79,7 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
       override def partitionEither[A, B, C](fa: List[A])
                                            (f: (A) => Either[B, C])
                                            (implicit A: Alternative[List]): (List[B], List[C]) =
-        fa.foldRight(List.empty[B], List.empty[C])((a, acc) => f(a) match {
+        fa.foldRight((List.empty[B], List.empty[C]))((a, acc) => f(a) match {
           case Left(b) => (b :: acc._1, acc._2)
           case Right(c) => (acc._1, c :: acc._2)
         })

From 2510240f8405f1126d0c0e6f1c63dd47eb18b0a9 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Tue, 5 Sep 2017 22:58:24 +0200
Subject: [PATCH 16/18] Add serializable

---
 core/src/main/scala/cats/data/NonEmptyVector.scala  | 6 +++---
 tests/src/test/scala/cats/tests/FoldableTests.scala | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/core/src/main/scala/cats/data/NonEmptyVector.scala b/core/src/main/scala/cats/data/NonEmptyVector.scala
index fda9c0af09..c77e6badc6 100644
--- a/core/src/main/scala/cats/data/NonEmptyVector.scala
+++ b/core/src/main/scala/cats/data/NonEmptyVector.scala
@@ -258,10 +258,10 @@ private[data] sealed trait NonEmptyVectorInstances {
         fa.foldRight(lb)(f)
 
       override def nonEmptyPartition[A, B, C](fa: NonEmptyVector[A])(f: (A) => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]] = {
-        import cats.syntax.reducible._
         import cats.syntax.either._
+        import cats.syntax.reducible._
 
-        fa.reduceLeftTo(a => f(a).bimap(NonEmptyVector.one, NonEmptyVector.one).toIor)((ior, a) => (f(a), ior) match {
+        reduceLeftTo(fa)(a => f(a).bimap(NonEmptyVector.one, NonEmptyVector.one).toIor)((ior, a) => (f(a), ior) match {
           case (Right(c), Ior.Left(_)) => ior.putRight(NonEmptyVector.one(c))
           case (Right(c), _) => ior.map(_ :+ c)
           case (Left(b), Ior.Right(_)) => ior.putLeft(NonEmptyVector.one(b))
@@ -319,7 +319,7 @@ private[data] sealed trait NonEmptyVectorInstances {
 
 }
 
-object NonEmptyVector extends NonEmptyVectorInstances {
+object NonEmptyVector extends NonEmptyVectorInstances with Serializable {
 
   def apply[A](head: A, tail: Vector[A]): NonEmptyVector[A] =
     new NonEmptyVector(head +: tail)
diff --git a/tests/src/test/scala/cats/tests/FoldableTests.scala b/tests/src/test/scala/cats/tests/FoldableTests.scala
index 3bf114fe13..4d399f6b8a 100644
--- a/tests/src/test/scala/cats/tests/FoldableTests.scala
+++ b/tests/src/test/scala/cats/tests/FoldableTests.scala
@@ -27,8 +27,8 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
 
   test("Foldable#partitionEither retains size") {
     forAll { (fi: F[Int], f: Int => Either[String, String]) =>
-      val list = Foldable[F].toList(fi)
-      val (lefts, rights) = Foldable[List].partitionEither(list)(f)
+      val vector = Foldable[F].toList(fi).toVector
+      val (lefts, rights) = Foldable[Vector].partitionEither(vector)(f)
       (lefts <+> rights).size.toLong should === (fi.size)
     }
   }

From ed75575f5443961d98ee707f8c9bdbc868cd5460 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 6 Sep 2017 21:32:13 +0200
Subject: [PATCH 17/18] Move sorted test to NonEmptyList

---
 .../test/scala/cats/tests/NonEmptyListTests.scala   | 13 ++++++++++++-
 .../src/test/scala/cats/tests/ReducibleTests.scala  | 11 -----------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/tests/src/test/scala/cats/tests/NonEmptyListTests.scala b/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
index 7abc1d1178..dcfda5a120 100644
--- a/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
+++ b/tests/src/test/scala/cats/tests/NonEmptyListTests.scala
@@ -282,9 +282,20 @@ class NonEmptyListTests extends CatsSuite {
     }
   }
 
+
   test("NonEmptyList#zipWith is consistent with List#zip and then List#map") {
     forAll { (a: NonEmptyList[Int], b: NonEmptyList[Int], f: (Int, Int) => Int) =>
-      a.zipWith(b)(f).toList should === (a.toList.zip(b.toList).map {case (x, y) => f(x, y)})
+      a.zipWith(b)(f).toList should ===(a.toList.zip(b.toList).map { case (x, y) => f(x, y) })
+    }
+  }
+  test("NonEmptyList#nonEmptyPartition remains sorted") {
+    forAll { (nel: NonEmptyList[Int], f: Int => Either[String, String]) =>
+
+      val sorted = nel.map(f).sorted
+      val ior = Reducible[NonEmptyList].nonEmptyPartition(sorted)(identity)
+
+      ior.left.map(xs => xs.sorted should === (xs))
+      ior.right.map(xs => xs.sorted should === (xs))
     }
   }
 }
diff --git a/tests/src/test/scala/cats/tests/ReducibleTests.scala b/tests/src/test/scala/cats/tests/ReducibleTests.scala
index b3585bd9bb..74e4ee5148 100644
--- a/tests/src/test/scala/cats/tests/ReducibleTests.scala
+++ b/tests/src/test/scala/cats/tests/ReducibleTests.scala
@@ -117,15 +117,4 @@ abstract class ReducibleCheck[F[_]: Reducible](name: String)(implicit ArbFInt: A
     }
   }
 
-  test("Reducible#nonEmptyPartition remains sorted") {
-    forAll { (fi: F[Int], f: Int => Either[String, String]) =>
-      val nel = Reducible[F].toNonEmptyList(fi)
-
-      val sorted = nel.map(f).sorted
-      val ior = sorted.nonEmptyPartition(identity)
-
-      ior.left.map(xs => xs.sorted should === (xs))
-      ior.right.map(xs => xs.sorted should === (xs))
-    }
-  }
 }

From e1d39b1d1efcdcfd789f43620a8db7a38c0c3ea9 Mon Sep 17 00:00:00 2001
From: Luka Jacobowitz <luka.jacobowitz@codecentric.de>
Date: Wed, 6 Sep 2017 21:41:29 +0200
Subject: [PATCH 18/18] Replicate sorted test to NEV and NES

---
 .../test/scala/cats/tests/NonEmptyVectorTests.scala | 13 ++++++++++++-
 tests/src/test/scala/cats/tests/OneAndTests.scala   | 13 +++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/tests/src/test/scala/cats/tests/NonEmptyVectorTests.scala b/tests/src/test/scala/cats/tests/NonEmptyVectorTests.scala
index a183825ea8..3b271e1b2f 100644
--- a/tests/src/test/scala/cats/tests/NonEmptyVectorTests.scala
+++ b/tests/src/test/scala/cats/tests/NonEmptyVectorTests.scala
@@ -314,9 +314,20 @@ class NonEmptyVectorTests extends CatsSuite {
     }
   }
 
+
   test("NonEmptyVector#zipWith is consistent with Vector#zip and then Vector#map") {
     forAll { (a: NonEmptyVector[Int], b: NonEmptyVector[Int], f: (Int, Int) => Int) =>
-      a.zipWith(b)(f).toVector should === (a.toVector.zip(b.toVector).map { case (x, y) => f(x, y)})
+      a.zipWith(b)(f).toVector should ===(a.toVector.zip(b.toVector).map { case (x, y) => f(x, y) })
+    }
+  }
+  test("NonEmptyVector#nonEmptyPartition remains sorted") {
+    forAll { (nev: NonEmptyVector[Int], f: Int => Either[String, String]) =>
+
+      val sorted = NonEmptyVector.fromVectorUnsafe(nev.map(f).toVector.sorted)
+      val ior = Reducible[NonEmptyVector].nonEmptyPartition(sorted)(identity)
+
+      ior.left.map(xs => xs.sorted should === (xs))
+      ior.right.map(xs => xs.sorted should === (xs))
     }
   }
 }
diff --git a/tests/src/test/scala/cats/tests/OneAndTests.scala b/tests/src/test/scala/cats/tests/OneAndTests.scala
index 8f02a6012e..bd0cd52359 100644
--- a/tests/src/test/scala/cats/tests/OneAndTests.scala
+++ b/tests/src/test/scala/cats/tests/OneAndTests.scala
@@ -128,6 +128,19 @@ class OneAndTests extends CatsSuite {
     }
   }
 
+  test("NonEmptyStream#nonEmptyPartition remains sorted") {
+    forAll { (nes: NonEmptyStream[Int], f: Int => Either[String, String]) =>
+
+      val nesf = nes.map(f)
+      val sortedStream = (nesf.head #:: nesf.tail).sorted
+      val sortedNes = OneAnd(sortedStream.head, sortedStream.tail)
+      val ior = Reducible[NonEmptyStream].nonEmptyPartition(sortedNes)(identity)
+
+      ior.left.map(xs => xs.sorted should === (xs))
+      ior.right.map(xs => xs.sorted should === (xs))
+    }
+  }
+
   test("reduceLeft consistent with foldLeft") {
     forAll { (nel: NonEmptyStream[Int], f: (Int, Int) => Int) =>
       nel.reduceLeft(f) should === (nel.tail.foldLeft(nel.head)(f))