Add UnorderedFoldable and UnorderedTraverse

core/src/main/scala/cats/Foldable.scala

@@ -3,6 +3,7 @@ package cats
 import scala.collection.mutable
 import cats.instances.either._
 import cats.instances.long._
+import cats.kernel.CommutativeMonoid
 import simulacrum.typeclass
 
 /**
@@ -15,6 +16,7 @@ import simulacrum.typeclass
  * `Foldable[_]` instance.
  *
  * Instances of Foldable should be ordered collections to allow for consistent folding.
+ * Use the `UnorderedFoldable` type class if you want to fold over unordered collections.
  *
  * Foldable[F] is implemented in terms of two basic methods:
  *
@@ -26,7 +28,7 @@ import simulacrum.typeclass
  *
  * See: [[http://www.cs.nott.ac.uk/~pszgmh/fold.pdf A tutorial on the universality and expressiveness of fold]]
  */
-@typeclass trait Foldable[F[_]] { self =>
+@typeclass trait Foldable[F[_]] extends UnorderedFoldable[F] { self =>
 
   /**
    * Left associative fold on 'F' using the function 'f'.
@@ -54,6 +56,7 @@ import simulacrum.typeclass
    */
   def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) => B): B
 
+
   /**
    * Right associative lazy fold on `F` using the folding function 'f'.
    *
@@ -360,7 +363,7 @@ import simulacrum.typeclass
    *
    * If there are no elements, the result is `false`.
    */
-  def exists[A](fa: F[A])(p: A => Boolean): Boolean =
+  override def exists[A](fa: F[A])(p: A => Boolean): Boolean =
     foldRight(fa, Eval.False) { (a, lb) =>
       if (p(a)) Eval.True else lb
     }.value
@@ -370,7 +373,7 @@ import simulacrum.typeclass
    *
    * If there are no elements, the result is `true`.
    */
-  def forall[A](fa: F[A])(p: A => Boolean): Boolean =
+  override def forall[A](fa: F[A])(p: A => Boolean): Boolean =
     foldRight(fa, Eval.True) { (a, lb) =>
       if (p(a)) lb else Eval.False
     }.value
@@ -509,10 +512,10 @@ import simulacrum.typeclass
   /**
    * Returns true if there are no elements. Otherwise false.
    */
-  def isEmpty[A](fa: F[A]): Boolean =
+  override def isEmpty[A](fa: F[A]): Boolean =
     foldRight(fa, Eval.True)((_, _) => Eval.False).value
 
-  def nonEmpty[A](fa: F[A]): Boolean =
+  override def nonEmpty[A](fa: F[A]): Boolean =
     !isEmpty(fa)
 
   /**
@@ -551,6 +554,11 @@ import simulacrum.typeclass
       val F = self
       val G = Foldable[G]
     }
+
+  override def unorderedFold[A: CommutativeMonoid](fa: F[A]): A = fold(fa)
+
+  override def unorderedFoldMap[A, B: CommutativeMonoid](fa: F[A])(f: (A) => B): B =
+    foldMap(fa)(f)
 }
 
 object Foldable {

core/src/main/scala/cats/Traverse.scala

@@ -16,7 +16,7 @@ import simulacrum.typeclass
  *
  * See: [[https://www.cs.ox.ac.uk/jeremy.gibbons/publications/iterator.pdf The Essence of the Iterator Pattern]]
  */
-@typeclass trait Traverse[F[_]] extends Functor[F] with Foldable[F] { self =>
+@typeclass trait Traverse[F[_]] extends Functor[F] with Foldable[F] with UnorderedTraverse[F] { self =>
 
   /**
    * Given a function which returns a G effect, thread this effect
@@ -124,4 +124,10 @@ import simulacrum.typeclass
    */
   def zipWithIndex[A](fa: F[A]): F[(A, Int)] =
     mapWithIndex(fa)((a, i) => (a, i))
+
+  override def unorderedTraverse[G[_] : CommutativeApplicative, A, B](sa: F[A])(f: (A) => G[B]): G[F[B]] =
+    traverse(sa)(f)
+
+  override def unorderedSequence[G[_] : CommutativeApplicative, A](fga: F[G[A]]): G[F[A]] =
+    sequence(fga)
 }

core/src/main/scala/cats/UnorderedFoldable.scala

@@ -0,0 +1,58 @@
+package cats
+
+import cats.kernel.CommutativeMonoid
+import simulacrum.typeclass
+import cats.instances.set._
+/**
+  * `UnorderedFoldable` is like a `Foldable` for unordered containers.
+  */
+@typeclass trait UnorderedFoldable[F[_]] {
+
+  def unorderedFoldMap[A, B: CommutativeMonoid](fa: F[A])(f: A => B): B
+
+  def unorderedFold[A: CommutativeMonoid](fa: F[A]): A =
+    unorderedFoldMap(fa)(identity)
+
+  def toSet[A](fa: F[A]): Set[A] =
+    unorderedFoldMap(fa)(a => Set(a))
+
+  /**
+    * Returns true if there are no elements. Otherwise false.
+    */
+  def isEmpty[A](fa: F[A]): Boolean =
+    exists(fa)(Function.const(true))
+
+  def nonEmpty[A](fa: F[A]): Boolean =
+    !isEmpty(fa)
+
+  /**
+    * Check whether at least one element satisfies the predicate.
+    *
+    * If there are no elements, the result is `false`.
+    */
+  def exists[A](fa: F[A])(p: A => Boolean): Boolean =
+    unorderedFoldMap(fa)(p)(UnorderedFoldable.orMonoid)
+
+  /**
+    * Check whether all elements satisfy the predicate.
+    *
+    * If there are no elements, the result is `true`.
+    */
+  def forall[A](fa: F[A])(p: A => Boolean): Boolean =
+    unorderedFoldMap(fa)(p)(UnorderedFoldable.andMonoid)
+}
+
+object UnorderedFoldable {
+  private val orMonoid: CommutativeMonoid[Boolean] = new CommutativeMonoid[Boolean] {
+    val empty: Boolean = false
+
+    def combine(x: Boolean, y: Boolean): Boolean = x || y
+  }
+
+  private val andMonoid: CommutativeMonoid[Boolean] = new CommutativeMonoid[Boolean] {
+    val empty: Boolean = true
+
+    def combine(x: Boolean, y: Boolean): Boolean = x && y
+  }
+
+}

core/src/main/scala/cats/UnorderedTraverse.scala

@@ -0,0 +1,14 @@
+package cats
+
+import simulacrum.typeclass
+
+/**
+  * `UnorderedTraverse` is like a `Traverse` for unordered containers. In addition to the traverse and sequence
+  * methods it provides nonEmptyTraverse and nonEmptySequence methods which require an `Apply` instance instead of `Applicative`.
+  */
+@typeclass trait UnorderedTraverse[F[_]] extends UnorderedFoldable[F] {
+  def unorderedTraverse[G[_]: CommutativeApplicative, A, B](sa: F[A])(f: A => G[B]): G[F[B]]
+
+  def unorderedSequence[G[_]: CommutativeApplicative, A](fga: F[G[A]]): G[F[A]] =
+    unorderedTraverse(fga)(identity)
+}

core/src/main/scala/cats/instances/map.scala

@@ -1,6 +1,8 @@
 package cats
 package instances
 
+import cats.kernel.CommutativeMonoid
+
 import scala.annotation.tailrec
 
 trait MapInstances extends cats.kernel.instances.MapInstances {
@@ -14,8 +16,16 @@ trait MapInstances extends cats.kernel.instances.MapInstances {
     }
 
   // scalastyle:off method.length
-  implicit def catsStdInstancesForMap[K]: FlatMap[Map[K, ?]] =
-    new FlatMap[Map[K, ?]] {
+  implicit def catsStdInstancesForMap[K]: UnorderedTraverse[Map[K, ?]] with FlatMap[Map[K, ?]] =
+    new UnorderedTraverse[Map[K, ?]] with FlatMap[Map[K, ?]] {
+
+      def unorderedTraverse[G[_], A, B](fa: Map[K, A])(f: A => G[B])(implicit G: CommutativeApplicative[G]): G[Map[K, B]] = {
+        val gba: Eval[G[Map[K, B]]] = Always(G.pure(Map.empty))
+        val gbb = Foldable.iterateRight(fa, gba){ (kv, lbuf) =>
+          G.map2Eval(f(kv._2), lbuf)({ (b, buf) => buf + (kv._1 -> b)})
+        }.value
+        G.map(gbb)(_.toMap)
+      }
 
       override def map[A, B](fa: Map[K, A])(f: A => B): Map[K, B] =
         fa.map { case (k, a) => (k, f(a)) }
@@ -39,6 +49,9 @@ trait MapInstances extends cats.kernel.instances.MapInstances {
       def flatMap[A, B](fa: Map[K, A])(f: (A) => Map[K, B]): Map[K, B] =
         fa.flatMap { case (k, a) => f(a).get(k).map((k, _)) }
 
+      def unorderedFoldMap[A, B: CommutativeMonoid](fa: Map[K, A])(f: (A) => B) =
+        fa.foldLeft(Monoid[B].empty){ case (b, (k, a)) => Monoid[B].combine(b, f(a)) }
+
       def tailRecM[A, B](a: A)(f: A => Map[K, Either[A, B]]): Map[K, B] = {
         val bldr = Map.newBuilder[K, B]
 
@@ -57,6 +70,14 @@ trait MapInstances extends cats.kernel.instances.MapInstances {
         f(a).foreach { case (k, a) => descend(k, a) }
         bldr.result
       }
+
+
+      override def isEmpty[A](fa: Map[K, A]): Boolean = fa.isEmpty
+
+      override def unorderedFold[A](fa: Map[K, A])(implicit A: CommutativeMonoid[A]): A =
+        A.combineAll(fa.values)
+
+      override def toSet[A](fa: Map[K, A]): Set[A] = fa.values.toSet
     }
   // scalastyle:on method.length
 }

core/src/main/scala/cats/instances/set.scala

@@ -1,17 +1,40 @@
 package cats
 package instances
 
+import cats.kernel.CommutativeMonoid
+
 import cats.syntax.show._
 
 trait SetInstances extends cats.kernel.instances.SetInstances {
 
-  implicit val catsStdInstancesForSet: MonoidK[Set] =
-    new MonoidK[Set] {
+  implicit val catsStdInstancesForSet: UnorderedTraverse[Set] with MonoidK[Set] =
+    new UnorderedTraverse[Set] with MonoidK[Set] {
+
+      def unorderedTraverse[G[_]: CommutativeApplicative, A, B](sa: Set[A])(f: A => G[B]): G[Set[B]] =
+        sa.foldLeft(Applicative[G].pure(Set.empty[B])) { (acc, a) =>
+          Apply[G].map2(acc, f(a))(_ + _)
+        }
+
+      override def unorderedSequence[G[_]: CommutativeApplicative, A](sa: Set[G[A]]): G[Set[A]] =
+        sa.foldLeft(Applicative[G].pure(Set.empty[A])) { (acc, a) =>
+          Apply[G].map2(acc, a)(_ + _)
+        }
 
       def empty[A]: Set[A] = Set.empty[A]
 
       def combineK[A](x: Set[A], y: Set[A]): Set[A] = x | y
 
+      def unorderedFoldMap[A, B](fa: Set[A])(f: A => B)(implicit B: CommutativeMonoid[B]): B =
+        fa.foldLeft(B.empty)((b, a) => B.combine(f(a), b))
+
+      override def unorderedFold[A](fa: Set[A])(implicit A: CommutativeMonoid[A]): A = A.combineAll(fa)
+
+      override def toSet[A](fa: Set[A]): Set[A] = fa
+
+      override def forall[A](fa: Set[A])(p: A => Boolean): Boolean =
+        fa.forall(p)
+
+      override def isEmpty[A](fa: Set[A]): Boolean = fa.isEmpty
     }
 
   implicit def catsStdShowForSet[A:Show]: Show[Set[A]] = new Show[Set[A]] {

core/src/main/scala/cats/syntax/foldable.scala

@@ -1,7 +1,7 @@
 package cats
 package syntax
 
-trait FoldableSyntax extends Foldable.ToFoldableOps {
+trait FoldableSyntax extends Foldable.ToFoldableOps with UnorderedFoldable.ToUnorderedFoldableOps {
   implicit final def catsSyntaxNestedFoldable[F[_]: Foldable, G[_], A](fga: F[G[A]]): NestedFoldableOps[F, G, A] =
     new NestedFoldableOps[F, G, A](fga)
 

docs/src/main/tut/typeclasses/foldable.md

@@ -10,7 +10,7 @@ scaladoc: "#cats.Foldable"
 Foldable type class instances can be defined for data structures that can be 
 folded to a summary value.
 
-In the case of a collection (such as `List` or `Set`), these methods will fold 
+In the case of a collection (such as `List` or `Vector`), these methods will fold
 together (combine) the values contained in the collection to produce a single 
 result. Most collection types have `foldLeft` methods, which will usually be 
 used by the associated `Foldable[_]` instance.

laws/src/main/scala/cats/laws/FoldableLaws.scala

@@ -5,7 +5,7 @@ import cats.implicits._
 
 import scala.collection.mutable
 
-trait FoldableLaws[F[_]] {
+trait FoldableLaws[F[_]] extends UnorderedFoldableLaws[F] {
   implicit def F: Foldable[F]
 
   def leftFoldConsistentWithFoldMap[A, B](
@@ -26,13 +26,11 @@ trait FoldableLaws[F[_]] {
     fa.foldMap(f) <-> fa.foldRight(Later(M.empty))((a, lb) => lb.map(f(a) |+| _)).value
   }
 
-  def existsConsistentWithFind[A](
-    fa: F[A],
-    p: A => Boolean
-  ): Boolean = {
+  def existsConsistentWithFind[A](fa: F[A], p: A => Boolean): Boolean = {
     F.exists(fa)(p) == F.find(fa)(p).isDefined
   }
 
+
   def existsLazy[A](fa: F[A]): Boolean = {
     var i = 0
     F.exists(fa){ _ =>
@@ -51,31 +49,6 @@ trait FoldableLaws[F[_]] {
     i == (if (F.isEmpty(fa)) 0 else 1)
   }
 
-  def forallConsistentWithExists[A](
-    fa: F[A],
-    p: A => Boolean
-  ): Boolean = {
-    if (F.forall(fa)(p)) {
-      val negationExists = F.exists(fa)(a => !(p(a)))
-
-      // if p is true for all elements, then there cannot be an element for which
-      // it does not hold.
-      !negationExists &&
-        // if p is true for all elements, then either there must be no elements
-        // or there must exist an element for which it is true.
-        (F.isEmpty(fa) || F.exists(fa)(p))
-    } else true // can't test much in this case
-  }
-
-  /**
-   * If `F[A]` is empty, forall must return true.
-   */
-  def forallEmpty[A](
-    fa: F[A],
-    p: A => Boolean
-  ): Boolean = {
-    !F.isEmpty(fa) || F.forall(fa)(p)
-  }
 
   /**
    * Monadic folding with identity monad is analogous to `foldLeft`.

laws/src/main/scala/cats/laws/TraverseLaws.scala

@@ -6,7 +6,7 @@ import cats.data.{Const, Nested, State, StateT}
 import cats.syntax.traverse._
 import cats.syntax.foldable._
 
-trait TraverseLaws[F[_]] extends FunctorLaws[F] with FoldableLaws[F] {
+trait TraverseLaws[F[_]] extends FunctorLaws[F] with FoldableLaws[F] with UnorderedTraverseLaws[F] {
   implicit override def F: Traverse[F]
 
   def traverseIdentity[A, B](fa: F[A], f: A => B): IsEq[F[B]] = {

laws/src/main/scala/cats/laws/UnorderedFoldableLaws.scala

@@ -0,0 +1,46 @@
+package cats
+package laws
+
+import cats.implicits._
+import cats.kernel.CommutativeMonoid
+
+trait UnorderedFoldableLaws[F[_]] {
+  implicit def F: UnorderedFoldable[F]
+
+  def unorderedFoldConsistentWithUnorderedFoldMap[A: CommutativeMonoid](fa: F[A]): IsEq[A] =
+    F.unorderedFoldMap(fa)(identity) <-> F.unorderedFold(fa)
+
+
+
+  def forallConsistentWithExists[A](fa: F[A], p: A => Boolean): Boolean = {
+    if (F.forall(fa)(p)) {
+      val negationExists = F.exists(fa)(a => !(p(a)))
+
+      // if p is true for all elements, then there cannot be an element for which
+      // it does not hold.
+      !negationExists &&
+        // if p is true for all elements, then either there must be no elements
+        // or there must exist an element for which it is true.
+        (F.isEmpty(fa) || F.exists(fa)(p))
+    } else true // can't test much in this case
+  }
+
+  /**
+    * If `F[A]` is empty, forall must return true.
+    */
+  def forallEmpty[A](fa: F[A], p: A => Boolean): Boolean = {
+    !F.isEmpty(fa) || F.forall(fa)(p)
+  }
+
+  def toSetRef[A](fa: F[A]): IsEq[Set[A]] =
+    F.unorderedFoldMap(fa)(a => Set(a)) <-> F.toSet(fa)
+
+  def nonEmptyRef[A](fa: F[A]): IsEq[Boolean] =
+    F.nonEmpty(fa) <-> !F.isEmpty(fa)
+
+}
+
+object UnorderedFoldableLaws {
+  def apply[F[_]](implicit ev: UnorderedFoldable[F]): UnorderedFoldableLaws[F] =
+    new UnorderedFoldableLaws[F] { def F: UnorderedFoldable[F] = ev }
+}