Adding NonEmptyVector

core/src/main/scala/cats/data/NonEmptyVector.scala

@@ -0,0 +1,179 @@
+package cats
+package data
+
+import scala.annotation.tailrec
+import scala.collection.immutable.VectorBuilder
+import cats.std.vector._
+
+/**
+ * A data type which represents a single element (head) and a Vector
+ * (tail).  This can be used to represent a Vector which is guaranteed
+ * to not be empty.
+ */
+final case class NonEmptyVector[A] private (vector: Vector[A]) {
+
+  def unwrap: Vector[A] = vector
+
+  def head: A = vector.head
+
+  def tail: Vector[A] = vector.tail
+
+  /**
+   * remove elements not matching the predicate
+   */
+  def filter(f: A => Boolean): Vector[A] = vector.filter(f)
+
+  /**
+   * Append another NonEmptyVector to this
+   */
+  def combine(other: NonEmptyVector[A]): NonEmptyVector[A] = NonEmptyVector(vector ++ other.vector)
+
+  /**
+   * find the first element matching the predicate, if one exists
+   */
+  def find(f: A => Boolean): Option[A] = vector.find(f)
+
+  /**
+   * Check whether at least one element satisfies the predicate.
+   */
+  def exists(f: A => Boolean): Boolean = vector.exists(f)
+
+  /**
+   * Check whether all elements satisfy the predicate.
+   */
+  def forall(f: A => Boolean): Boolean = vector.forall(f)
+
+  /**
+   * Left-associative fold using f.
+   */
+  def foldLeft[B](b: B)(f: (B, A) => B): B =
+    vector.foldLeft(b)(f)
+
+  /**
+   * Right-associative fold using f.
+   */
+  def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
+    Eval.defer(Foldable[Vector].foldRight(vector, lb)(f))
+
+  /**
+    * Applies f to all the elements
+    */
+  def map[B](f: A => B): NonEmptyVector[B] =
+    NonEmptyVector(vector.map(f))
+
+  /**
+    *  Applies f to all elements and combines the result
+    */
+  def flatMap[B](f: A => NonEmptyVector[B]): NonEmptyVector[B] =
+    NonEmptyVector(vector.flatMap(a => f(a).vector))
+
+  /**
+   * Typesafe equality operator.
+   *
+   * This method is similar to == except that it only allows two
+   * NonEmptyVector[A] values to be compared to each other, and uses
+   * equality provided by Eq[_] instances, rather than using the
+   * universal equality provided by .equals.
+   */
+  def ===(that: NonEmptyVector[A])(implicit A: Eq[A]): Boolean = Eq[Vector[A]].eqv(vector, that.vector)
+
+  /**
+   * Typesafe stringification method.
+   *
+   * This method is similar to .toString except that it stringifies
+   * values according to Show[_] instances, rather than using the
+   * universal .toString method.
+   */
+  def show(implicit A: Show[A]): String =
+    s"NonEmptyVector(${A.show(head)}, ${Show[Vector[A]].show(tail)})"
+}
+
+private[data] sealed trait NonEmptyVectorInstances extends NonEmptyVectorLowPriority2 {
+
+  implicit def catsDataEqForNonEmptyVector[A](implicit A: Eq[A]): Eq[NonEmptyVector[A]] =
+    new Eq[NonEmptyVector[A]]{
+      def eqv(x: NonEmptyVector[A], y: NonEmptyVector[A]): Boolean = x === y
+    }
+
+  implicit def catsDataShowForNonEmptyVector[A](implicit A: Show[A]): Show[NonEmptyVector[A]] =
+    Show.show[NonEmptyVector[A]](_.show)
+
+  implicit def catsDataSemigroupKForNonEmptyVector: SemigroupK[NonEmptyVector] =
+    new SemigroupK[NonEmptyVector] {
+      def combineK[A](a: NonEmptyVector[A], b: NonEmptyVector[A]): NonEmptyVector[A] =
+        a combine b
+    }
+
+  implicit def catsDataSemigroupForNonEmptyVector[A]: Semigroup[NonEmptyVector[A]] =
+    catsDataSemigroupKForNonEmptyVector.algebra
+
+  implicit def catsDataReducibleForNonEmptyVector: Reducible[NonEmptyVector] =
+    new NonEmptyReducible[NonEmptyVector, Vector] {
+      override def split[A](fa: NonEmptyVector[A]): (A, Vector[A]) = (fa.head, fa.tail)
+
+      override def size[A](fa: NonEmptyVector[A]): Long = 1 + fa.tail.size.toLong
+    }
+
+  implicit def catsDataMonadForNonEmptyVector: Monad[NonEmptyVector] =
+    new Monad[NonEmptyVector] {
+      override def map[A, B](fa: NonEmptyVector[A])(f: A => B): NonEmptyVector[B] =
+        fa map f
+
+      def pure[A](x: A): NonEmptyVector[A] =
+        NonEmptyVector(x, Vector.empty)
+
+      def flatMap[A, B](fa: NonEmptyVector[A])(f: A => NonEmptyVector[B]): NonEmptyVector[B] =
+        fa flatMap f
+    }
+}
+
+trait NonEmptyVectorLowPriority0 {
+
+  implicit def catsDataComonadForNonEmptyVector: Comonad[NonEmptyVector] = new Comonad[NonEmptyVector] {
+
+    def coflatMap[A, B](fa: NonEmptyVector[A])(f: NonEmptyVector[A] => B): NonEmptyVector[B] = {
+        @tailrec def consume(as: Vector[A], buf: VectorBuilder[B]): Vector[B] =
+          as match {
+            case a +: as => consume(as, buf += f(NonEmptyVector(a, as)))
+            case _ => buf.result()
+          }
+        NonEmptyVector(f(fa), consume(fa.tail, new VectorBuilder[B]))
+      }
+
+
+    def extract[A](fa: NonEmptyVector[A]): A = fa.head
+
+    def map[A, B](fa: NonEmptyVector[A])(f: A => B): NonEmptyVector[B] = fa map f
+  }
+}
+
+trait NonEmptyVectorLowPriority1 extends NonEmptyVectorLowPriority0 {
+  implicit def catsDataFunctorForNonEmptyVector: Functor[NonEmptyVector] =
+    new Functor[NonEmptyVector] {
+      def map[A, B](fa: NonEmptyVector[A])(f: A => B): NonEmptyVector[B] =
+        fa map f
+    }
+
+}
+
+trait NonEmptyVectorLowPriority2 extends NonEmptyVectorLowPriority1 {
+  implicit def catsDataTraverseForNonEmptyVector: Traverse[NonEmptyVector] =
+    new Traverse[NonEmptyVector] {
+      def traverse[G[_], A, B](fa: NonEmptyVector[A])(f: (A) => G[B])(implicit G: Applicative[G]): G[NonEmptyVector[B]] =
+      G.map2Eval(f(fa.head), Always(Traverse[Vector].traverse(fa.tail)(f)))(NonEmptyVector(_, _)).value
+
+
+      def foldLeft[A, B](fa: NonEmptyVector[A], b: B)(f: (B, A) => B): B =
+        fa.foldLeft(b)(f)
+
+      def foldRight[A, B](fa: NonEmptyVector[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
+        fa.foldRight(lb)(f)
+    }
+}
+
+object NonEmptyVector extends NonEmptyVectorInstances {
+
+  def apply[A](head: A, tail: Vector[A]): NonEmptyVector[A] = NonEmptyVector(head +: tail)
+
+  def apply[A](head: A, tail: A*): NonEmptyVector[A] = NonEmptyVector(head +: tail.toVector)
+}

core/src/main/scala/cats/data/package.scala

@@ -2,7 +2,6 @@ package cats
 
 package object data {
   type NonEmptyList[A] = OneAnd[List, A]
-  type NonEmptyVector[A] = OneAnd[Vector, A]
   type NonEmptyStream[A] = OneAnd[Stream, A]
   type ValidatedNel[E, A] = Validated[NonEmptyList[E], A]
 
@@ -11,11 +10,6 @@ package object data {
   def NonEmptyList[A](head: A, tail: A*): NonEmptyList[A] =
     OneAnd[List, A](head, tail.toList)
 
-  def NonEmptyVector[A](head: A, tail: Vector[A] = Vector.empty): NonEmptyVector[A] =
-    OneAnd(head, tail)
-  def NonEmptyVector[A](head: A, tail: A*): NonEmptyVector[A] =
-    OneAnd(head, tail.toVector)
-
   def NonEmptyStream[A](head: A, tail: Stream[A] = Stream.empty): NonEmptyStream[A] =
     OneAnd(head, tail)
   def NonEmptyStream[A](head: A, tail: A*): NonEmptyStream[A] =

docs/src/main/tut/oneand.md

@@ -21,10 +21,10 @@ type NonEmptyList[A] = OneAnd[List, A]
 
 which is the actual implementation of non-empty lists in cats.  By
 having the higher kinded type parameter `F[_]`, `OneAnd` is also able
-to represent other "non-empty" data structures, e.g.
+to represent other "non-empty" data structures e.g.
 
 ```tut:silent
 import cats.data.OneAnd
 
-type NonEmptyVector[A] = OneAnd[Vector, A]
-```
+type NonEmptyStream[A] = OneAnd[Stream, A]
+```

laws/src/main/scala/cats/laws/discipline/Arbitrary.scala

@@ -23,6 +23,9 @@ object arbitrary extends ArbitraryInstances0 {
   implicit def catsLawsArbitraryForOneAnd[F[_], A](implicit A: Arbitrary[A], F: Arbitrary[F[A]]): Arbitrary[OneAnd[F, A]] =
     Arbitrary(F.arbitrary.flatMap(fa => A.arbitrary.map(a => OneAnd(a, fa))))
 
+  implicit def catsLawsArbitraryForNonEmptyVector[A](implicit A: Arbitrary[A]): Arbitrary[NonEmptyVector[A]] =
+    Arbitrary(implicitly[Arbitrary[Vector[A]]].arbitrary.flatMap(fa => A.arbitrary.map(a => NonEmptyVector(a, fa))))
+
   implicit def catsLawsArbitraryForXor[A, B](implicit A: Arbitrary[A], B: Arbitrary[B]): Arbitrary[A Xor B] =
     Arbitrary(Gen.oneOf(A.arbitrary.map(Xor.left), B.arbitrary.map(Xor.right)))
 

tests/src/test/scala/cats/tests/NonEmptyVectorTests.scala

@@ -0,0 +1,171 @@
+package cats
+package tests
+
+import cats.kernel.laws.{GroupLaws, OrderLaws}
+
+import cats.data.NonEmptyVector
+import cats.laws.discipline.{ComonadTests, FunctorTests, SemigroupKTests, FoldableTests, MonadTests, SerializableTests, CartesianTests, TraverseTests, ReducibleTests}
+import cats.laws.discipline.arbitrary._
+
+class NonEmptyVectorTests extends CatsSuite {
+  // Lots of collections here.. telling ScalaCheck to calm down a bit
+  implicit override val generatorDrivenConfig: PropertyCheckConfiguration =
+    PropertyCheckConfig(maxSize = 5, minSuccessful = 20)
+
+  checkAll("NonEmptyVector[Int]", OrderLaws[NonEmptyVector[Int]].eqv)
+
+  checkAll("NonEmptyVector[Int] with Option", TraverseTests[NonEmptyVector].traverse[Int, Int, Int, Int, Option, Option])
+  checkAll("Traverse[NonEmptyVector[A]]", SerializableTests.serializable(Traverse[NonEmptyVector]))
+
+  checkAll("NonEmptyVector[Int]", ReducibleTests[NonEmptyVector].reducible[Option, Int, Int])
+  checkAll("Reducible[NonEmptyVector]", SerializableTests.serializable(Reducible[NonEmptyVector]))
+
+  implicit val iso = CartesianTests.Isomorphisms.invariant[NonEmptyVector](NonEmptyVector.catsDataFunctorForNonEmptyVector)
+
+  // Test instances that have more general constraints
+  {
+    checkAll("NonEmptyVector[Int]", CartesianTests[NonEmptyVector].cartesian[Int, Int, Int])
+    checkAll("Cartesian[NonEmptyVector]", SerializableTests.serializable(Cartesian[NonEmptyVector]))
+  }
+
+  {
+    checkAll("NonEmptyVector[Int]", FunctorTests[NonEmptyVector].functor[Int, Int, Int])
+    checkAll("Functor[NonEmptyVector]", SerializableTests.serializable(Functor[NonEmptyVector]))
+  }
+
+  {
+    checkAll("NonEmptyVector[Int]", SemigroupKTests[NonEmptyVector].semigroupK[Int])
+    checkAll("NonEmptyVector[Int]", GroupLaws[NonEmptyVector[Int]].semigroup)
+    checkAll("SemigroupK[NonEmptyVector]", SerializableTests.serializable(SemigroupK[NonEmptyVector]))
+    checkAll("Semigroup[NonEmptyVector[Int]]", SerializableTests.serializable(Semigroup[NonEmptyVector[Int]]))
+  }
+
+  {
+    checkAll("NonEmptyVector[Int]", FoldableTests[NonEmptyVector].foldable[Int, Int])
+    checkAll("Foldable[NonEmptyVector]", SerializableTests.serializable(Foldable[NonEmptyVector]))
+  }
+
+  {
+    // Test functor and subclasses don't have implicit conflicts
+    implicitly[Functor[NonEmptyVector]]
+    implicitly[Monad[NonEmptyVector]]
+    implicitly[Comonad[NonEmptyVector]]
+  }
+
+  {
+    checkAll("NonEmptyVector[Int]", MonadTests[NonEmptyVector].monad[Int, Int, Int])
+    checkAll("Monad[NonEmptyVector]", SerializableTests.serializable(Monad[NonEmptyVector]))
+  }
+
+  {
+    checkAll("NonEmptyVector[Int]", ComonadTests[NonEmptyVector].comonad[Int, Int, Int])
+    checkAll("Comonad[NonEmptyVector]", SerializableTests.serializable(Comonad[NonEmptyVector]))
+  }
+
+
+  test("size is consistent with toList.size") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int]) =>
+      nonEmptyVector.size should === (nonEmptyVector.toList.size.toLong)
+    }
+  }
+
+
+  test("Show is not empty and is formatted as expected") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int]) =>
+      nonEmptyVector.show.nonEmpty should === (true)
+      nonEmptyVector.show.startsWith("NonEmptyVector(") should === (true)
+      nonEmptyVector.show should === (implicitly[Show[NonEmptyVector[Int]]].show(nonEmptyVector))
+      nonEmptyVector.show.contains(nonEmptyVector.head.show) should === (true)
+    }
+  }
+
+  test("Show is formatted correctly") {
+    val nonEmptyVector = NonEmptyVector("Test", Vector.empty)
+    nonEmptyVector.show should === ("NonEmptyVector(Test, Vector())")
+  }
+
+  test("Creating NonEmptyVector + unwrap is identity") {
+    forAll { (i: Int, tail: Vector[Int]) =>
+      val vector = i +: tail
+      val nonEmptyVector = NonEmptyVector(i, tail)
+      vector should === (nonEmptyVector.unwrap)
+    }
+  }
+
+  test("NonEmptyVector#filter is consistent with NonEmptyVector#filter") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], p: Int => Boolean) =>
+      val vector = nonEmptyVector.unwrap
+      nonEmptyVector.filter(p) should === (vector.filter(p))
+    }
+  }
+
+  test("NonEmptyVector#find is consistent with NonEmptyVector#find") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], p: Int => Boolean) =>
+      val vector = nonEmptyVector.unwrap
+      nonEmptyVector.find(p) should === (vector.find(p))
+    }
+  }
+
+  test("NonEmptyVector#exists is consistent with NonEmptyVector#exists") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], p: Int => Boolean) =>
+      val vector = nonEmptyVector.unwrap
+      nonEmptyVector.exists(p) should === (vector.exists(p))
+    }
+  }
+
+  test("NonEmptyVector#forall is consistent with NonEmptyVector#forall") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], p: Int => Boolean) =>
+      val vector = nonEmptyVector.unwrap
+      nonEmptyVector.forall(p) should === (vector.forall(p))
+    }
+  }
+
+  test("NonEmptyVector#map is consistent with NonEmptyVector#map") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], p: Int => String) =>
+      val vector = nonEmptyVector.unwrap
+      nonEmptyVector.map(p).unwrap should === (vector.map(p))
+    }
+  }
+
+  test("reduceLeft consistent with foldLeft") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], f: (Int, Int) => Int) =>
+      nonEmptyVector.reduceLeft(f) should === (nonEmptyVector.tail.foldLeft(nonEmptyVector.head)(f))
+    }
+  }
+
+  test("reduceRight consistent with foldRight") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], f: (Int, Eval[Int]) => Eval[Int]) =>
+      nonEmptyVector.reduceRight(f).value should === (nonEmptyVector.tail.foldRight(nonEmptyVector.head)((a, b) => f(a, Now(b)).value))
+    }
+  }
+
+  test("reduce consistent with fold") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int]) =>
+      nonEmptyVector.reduce should === (nonEmptyVector.fold)
+    }
+  }
+
+  test("reduce consistent with reduceK") {
+    forAll { (nonEmptyVector: NonEmptyVector[Option[Int]]) =>
+      nonEmptyVector.reduce(SemigroupK[Option].algebra[Int]) should === (nonEmptyVector.reduceK)
+    }
+  }
+
+  test("reduceLeftToOption consistent with foldLeft + Option") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], f: Int => String, g: (String, Int) => String) =>
+      val expected = nonEmptyVector.tail.foldLeft(Option(f(nonEmptyVector.head))) { (opt, i) =>
+        opt.map(s => g(s, i))
+      }
+      nonEmptyVector.reduceLeftToOption(f)(g) should === (expected)
+    }
+  }
+
+  test("reduceRightToOption consistent with foldRight + Option") {
+    forAll { (nonEmptyVector: NonEmptyVector[Int], f: Int => String, g: (Int, Eval[String]) => Eval[String]) =>
+      val expected = nonEmptyVector.tail.foldRight(Option(f(nonEmptyVector.head))) { (i, opt) =>
+        opt.map(s => g(i, Now(s)).value)
+      }
+      nonEmptyVector.reduceRightToOption(f)(g).value should === (expected)
+    }
+  }
+}