Fix Foldabe#dropWhile_ bug.

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

@@ -181,13 +181,22 @@ import simulacrum.typeclass
       if (p(a)) buf += a else buf
     }.toList
 
+  /**
+   * Convert F[A] to a List[A], retaining only initial elements which
+   * match `p`.
+   */
+  def takeWhile_[A](fa: F[A])(p: A => Boolean): List[A] =
+    foldRight(fa, Now(List.empty[A])) { (a, llst) =>
+      if (p(a)) llst.map(a :: _) else Now(Nil)
+    }.value
+
   /**
    * Convert F[A] to a List[A], dropping all initial elements which
    * match `p`.
    */
   def dropWhile_[A](fa: F[A])(p: A => Boolean): List[A] =
     foldLeft(fa, mutable.ListBuffer.empty[A]) { (buf, a) =>
-      if (buf.nonEmpty || p(a)) buf += a else buf
+      if (buf.nonEmpty || !p(a)) buf += a else buf
     }.toList
 
   /**

core/src/main/scala/cats/std/all.scala

@@ -10,6 +10,7 @@ trait AllInstances
   with    SetInstances
   with    StreamInstances
   with    VectorInstances
+  with    IterableInstances
   with    AnyValInstances
   with    MapInstances
   with    BigIntInstances

core/src/main/scala/cats/std/iterable.scala

@@ -0,0 +1,18 @@
+package cats
+package std
+
+trait IterableInstances {
+  implicit val iterableInstance: Foldable[Iterable] =
+    new Foldable[Iterable] {
+
+      def foldLeft[A, B](fa: Iterable[A], b: B)(f: (B, A) => B): B =
+        fa.foldLeft(b)(f)
+
+      def foldRight[A, B](fa: Iterable[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] = {
+        val it = fa.iterator
+        def loop(): Eval[B] =
+          if (it.hasNext) f(it.next, Eval.defer(loop())) else lb
+        Eval.defer(loop())
+      }
+    }
+}

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

@@ -13,6 +13,7 @@ package object std {
   object vector     extends VectorInstances
   object map        extends MapInstances
   object future     extends FutureInstances
+  object iterable   extends IterableInstances
 
   object string     extends StringInstances
   object int        extends IntInstances

tests/src/test/scala/cats/tests/FoldableTests.scala

@@ -5,6 +5,10 @@ import org.scalatest.prop.PropertyChecks
 import org.scalacheck.{Arbitrary, Gen}
 import org.scalacheck.Arbitrary.arbitrary
 
+import cats.data.Streaming
+import cats.std.all._
+import cats.laws.discipline.arbitrary._
+
 abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arbitrary[F[Int]]) extends CatsSuite with PropertyChecks {
 
   def iterator[T](fa: F[T]): Iterator[T]
@@ -26,6 +30,7 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
       fa.forall(_ > n) should === (iterator(fa).forall(_ > n))
       fa.filter_(_ > n) should === (iterator(fa).filter(_ > n).toList)
       fa.dropWhile_(_ > n) should === (iterator(fa).dropWhile(_ > n).toList)
+      fa.takeWhile_(_ > n) should === (iterator(fa).takeWhile(_ > n).toList)
     }
   }
 
@@ -96,3 +101,27 @@ class FoldableTestsAdditional extends CatsSuite {
     assert(dangerous.toStreaming.take(3).toList == List(0, 1, 2))
   }
 }
+
+class FoldableListCheck extends FoldableCheck[List]("list") {
+  def iterator[T](list: List[T]): Iterator[T] = list.iterator
+}
+
+class FoldableVectorCheck extends FoldableCheck[Vector]("vector") {
+  def iterator[T](vector: Vector[T]): Iterator[T] = vector.iterator
+}
+
+class FoldableStreamCheck extends FoldableCheck[Stream]("stream") {
+  def iterator[T](stream: Stream[T]): Iterator[T] = stream.iterator
+}
+
+class FoldableStreamingCheck extends FoldableCheck[Streaming]("streaming") {
+  def iterator[T](streaming: Streaming[T]): Iterator[T] = streaming.iterator
+}
+
+class FoldableIterableCheck extends FoldableCheck[Iterable]("iterable") {
+  def iterator[T](iterable: Iterable[T]): Iterator[T] = iterable.iterator
+}
+
+class FoldableMapCheck extends FoldableCheck[Map[Int, ?]]("map") {
+  def iterator[T](map: Map[Int, T]): Iterator[T] = map.iterator.map(_._2)
+}