Adding get for Foldable

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

@@ -1,6 +1,7 @@
 package cats
 
 import scala.collection.mutable
+import cats.instances.either._
 import cats.instances.long._
 import simulacrum.typeclass
 
@@ -151,6 +152,19 @@ import simulacrum.typeclass
    */
   def size[A](fa: F[A]): Long = foldMap(fa)(_ => 1)
 
+  /**
+    * Get the element at the index of the `Foldable`.
+    */
+  def get[A](fa: F[A])(idx: Long): Option[A] =
+    if (idx < 0L) None
+    else
+      foldM[Either[A, ?], A, Long](fa, 0L) { (i, a) =>
+        if (i == idx) Left(a) else Right(i + 1L)
+      } match {
+        case Left(a) => Some(a)
+        case Right(_) => None
+      }
+
   /**
    * Fold implemented using the given Monoid[A] instance.
    */

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

@@ -81,6 +81,10 @@ private[data] sealed abstract class ConstInstances extends ConstInstances0 {
 
     def foldRight[A, B](fa: Const[C, A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] = lb
 
+    override def size[A](fa: Const[C, A]): Long = 0L
+
+    override def get[A](fa: Const[C, A])(idx: Long): Option[A] = None
+
     override def traverse[G[_]: Applicative, A, B](fa: Const[C, A])(f: A => G[B]): G[Const[C, B]] =
       fa.traverse(f)
   }

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

@@ -63,6 +63,12 @@ private[data] sealed trait IdTFoldable[F[_]] extends Foldable[IdT[F, ?]] {
 
   def foldRight[A, B](fa: IdT[F, A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
     fa.foldRight(lb)(f)
+
+  override def size[A](fa: IdT[F, A]): Long =
+    F0.size(fa.value)
+
+  override def get[A](fa: IdT[F, A])(idx: Long): Option[A] =
+    F0.get(fa.value)(idx)
 }
 
 private[data] sealed trait IdTTraverse[F[_]] extends Traverse[IdT[F, ?]] with IdTFoldable[F] {

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

@@ -209,6 +209,11 @@ private[data] sealed abstract class IorInstances0 {
     def foldRight[B, C](fa: A Ior B, lc: Eval[C])(f: (B, Eval[C]) => Eval[C]): Eval[C] =
       fa.foldRight(lc)(f)
 
+    override def size[B](fa: A Ior B): Long = fa.fold(_ => 0L, _ => 1L, (_, _) => 1L)
+
+    override def get[B](fa: A Ior B)(idx: Long): Option[B] =
+      if (idx == 0L) fa.fold(_ => None, Some(_), (_, b) => Some(b)) else None
+
     override def forall[B](fa: Ior[A, B])(p: (B) => Boolean): Boolean = fa.forall(p)
 
     override def exists[B](fa: Ior[A, B])(p: (B) => Boolean): Boolean = fa.exists(p)

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

@@ -436,6 +436,9 @@ private[data] sealed trait NonEmptyListInstances extends NonEmptyListInstances0
       override def toList[A](fa: NonEmptyList[A]): List[A] = fa.toList
 
       override def toNonEmptyList[A](fa: NonEmptyList[A]): NonEmptyList[A] = fa
+
+      override def get[A](fa: NonEmptyList[A])(idx: Long): Option[A] =
+        if (idx == 0) Some(fa.head) else Foldable[List].get(fa.tail)(idx - 1)
     }
 
   implicit def catsDataShowForNonEmptyList[A](implicit A: Show[A]): Show[NonEmptyList[A]] =

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

@@ -235,6 +235,9 @@ 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 get[A](fa: NonEmptyVector[A])(idx: Long): Option[A] =
+        if (idx < Int.MaxValue) fa.get(idx.toInt) else None
+
       def tailRecM[A, B](a: A)(f: A => NonEmptyVector[Either[A, B]]): NonEmptyVector[B] = {
         val buf = new VectorBuilder[B]
         @tailrec def go(v: NonEmptyVector[Either[A, B]]): Unit = v.head match {

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

@@ -117,6 +117,9 @@ private[data] sealed trait OneAndInstances extends OneAndLowPriority2 {
     new NonEmptyReducible[OneAnd[F, ?], F] {
       override def split[A](fa: OneAnd[F, A]): (A, F[A]) = (fa.head, fa.tail)
 
+      override def get[A](fa: OneAnd[F, A])(idx: Long): Option[A] =
+        if (idx == 0L) Some(fa.head) else F.get(fa.tail)(idx - 1L)
+
       override def size[A](fa: OneAnd[F, A]): Long = 1 + F.size(fa.tail)
     }
 

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

@@ -404,6 +404,9 @@ private[data] sealed abstract class ValidatedInstances2 {
       override def size[A](fa: Validated[E, A]): Long =
         fa.fold(_ => 0L, _ => 1L)
 
+      override def get[A](fa: Validated[E, A])(idx: Long): Option[A] =
+        if (idx == 0L) fa.fold(_ => None, Some(_)) else None
+
       override def foldMap[A, B](fa: Validated[E, A])(f: A => B)(implicit B: Monoid[B]): B =
         fa.fold(_ => B.empty, f)
 

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

@@ -112,6 +112,9 @@ trait EitherInstances extends cats.kernel.instances.EitherInstances {
       override def size[B](fab: Either[A, B]): Long =
         fab.fold(_ => 0L, _ => 1L)
 
+      override def get[B](fab: Either[A, B])(idx: Long): Option[B] =
+        if (idx == 0L) fab.fold(_ => None, Some(_)) else None
+
       override def foldMap[B, C](fab: Either[A, B])(f: B => C)(implicit C: Monoid[C]): C =
         fab.fold(_ => C.empty, f)
 

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

@@ -70,6 +70,16 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
           G.map2Eval(f(a), lglb)(_ :: _)
         }.value
 
+      @tailrec
+      override def get[A](fa: List[A])(idx: Long): Option[A] =
+        fa match {
+          case Nil => None
+          case h :: tail =>
+            if (idx < 0) None
+            else if (idx == 0) Some(h)
+            else get(tail)(idx - 1)
+        }
+
       override def exists[A](fa: List[A])(p: A => Boolean): Boolean =
         fa.exists(p)
 

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

@@ -77,6 +77,19 @@ trait MapInstances extends cats.kernel.instances.MapInstances {
 
       override def size[A](fa: Map[K, A]): Long = fa.size.toLong
 
+      override def get[A](fa: Map[K, A])(idx: Long): Option[A] = {
+        @tailrec
+        def go(idx: Int, it: Iterator[A]): Option[A] = {
+          if ( it.hasNext ) {
+            if (idx == 0) Some(it.next) else {
+              it.next
+              go(idx - 1, it)
+            }
+          } else None
+        }
+        if (idx > 0L && idx < fa.size && idx < Int.MaxValue) go(idx.toInt, fa.valuesIterator) else None
+      }
+
       override def isEmpty[A](fa: Map[K, A]): Boolean = fa.isEmpty
 
       override def foldM[G[_], A, B](fa: Map[K, A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] =

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

@@ -86,6 +86,9 @@ trait OptionInstances extends cats.kernel.instances.OptionInstances {
 
       override def maximumOption[A](fa: Option[A])(implicit A: Order[A]): Option[A] = fa
 
+      override def get[A](fa: Option[A])(idx: Long): Option[A] =
+        if (idx == 0L) fa else None
+
       override def size[A](fa: Option[A]): Long = fa.fold(0L)(_ => 1L)
 
       override def foldMap[A, B](fa: Option[A])(f: A => B)(implicit B: Monoid[B]): B =

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

@@ -1,6 +1,8 @@
 package cats
 package instances
 
+import scala.annotation.tailrec
+
 import cats.syntax.show._
 
 trait SetInstances extends cats.kernel.instances.SetInstances {
@@ -18,6 +20,19 @@ trait SetInstances extends cats.kernel.instances.SetInstances {
       def foldRight[A, B](fa: Set[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
         Foldable.iterateRight(fa.iterator, lb)(f)
 
+      override def get[A](fa: Set[A])(idx: Long): Option[A] = {
+        @tailrec
+        def go(idx: Int, it: Iterator[A]): Option[A] = {
+          if (it.hasNext) {
+            if (idx == 0) Some(it.next) else {
+              it.next
+              go(idx - 1, it)
+            }
+          } else None
+        }
+        if (idx < Int.MaxValue && idx >= 0L)  go(idx.toInt, fa.toIterator) else None
+      }
+
       override def size[A](fa: Set[A]): Long = fa.size.toLong
 
       override def exists[A](fa: Set[A])(p: A => Boolean): Boolean =

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

@@ -101,6 +101,17 @@ trait StreamInstances extends cats.kernel.instances.StreamInstances {
       override def forall[A](fa: Stream[A])(p: A => Boolean): Boolean =
         fa.forall(p)
 
+      override def get[A](fa: Stream[A])(idx: Long): Option[A] = {
+        @tailrec
+        def go(idx: Long, s: Stream[A]): Option[A] =
+          s match {
+            case h #:: tail =>
+              if (idx == 0L) Some(h) else go(idx - 1L, tail)
+            case _ => None
+          }
+        if (idx < 0L) None else go(idx, fa)
+      }
+
       override def isEmpty[A](fa: Stream[A]): Boolean = fa.isEmpty
 
       override def filter[A](fa: Stream[A])(f: A => Boolean): Stream[A] = fa.filter(f)

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

@@ -91,6 +91,13 @@ trait TryInstances extends TryInstances1 {
       override def reduceRightOption[A](fa: Try[A])(f: (A, Eval[A]) => Eval[A]): Eval[Option[A]] =
         Now(fa.toOption)
 
+      override def get[A](fa: Try[A])(idx: Long): Option[A] =
+        fa match {
+          case Failure(_) => None
+          case Success(a) =>
+            if (idx == 0L) Some(a) else None
+        }
+
       override def size[A](fa: Try[A]): Long =
         fa match {
           case Failure(_) => 0L

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

@@ -66,6 +66,9 @@ sealed trait Tuple2Instances extends Tuple2Instances1 {
 
       override def size[A](fa: (X, A)): Long = 1L
 
+      override def get[A](fa: (X, A))(idx: Long): Option[A] =
+        if (idx == 0L) Some(fa._2) else None
+
       override def exists[A](fa: (X, A))(p: A => Boolean): Boolean = p(fa._2)
 
       override def forall[A](fa: (X, A))(p: A => Boolean): Boolean = p(fa._2)

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

@@ -73,6 +73,9 @@ trait VectorInstances extends cats.kernel.instances.VectorInstances {
 
       override def size[A](fa: Vector[A]): Long = fa.size.toLong
 
+      override def get[A](fa: Vector[A])(idx: Long): Option[A] =
+        if (idx < Int.MaxValue && fa.size > idx && idx >= 0) Some(fa(idx.toInt)) else None
+
       override def traverse[G[_], A, B](fa: Vector[A])(f: A => G[B])(implicit G: Applicative[G]): G[Vector[B]] =
         foldRight[A, G[Vector[B]]](fa, Always(G.pure(Vector.empty))){ (a, lgvb) =>
           G.map2Eval(f(a), lgvb)(_ +: _)

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

@@ -70,6 +70,8 @@ package object cats {
         Now(Some(f(fa)))
       override def reduceMap[A, B](fa: Id[A])(f: A => B)(implicit B: Semigroup[B]): B = f(fa)
       override def size[A](fa: Id[A]): Long = 1L
+      override def get[A](fa: Id[A])(idx: Long): Option[A] =
+        if (idx == 0L) Some(fa) else None
       override def isEmpty[A](fa: Id[A]): Boolean = false
   }
 

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

@@ -13,9 +13,15 @@ abstract class FoldableCheck[F[_]: Foldable](name: String)(implicit ArbFInt: Arb
 
   def iterator[T](fa: F[T]): Iterator[T]
 
-  test(s"Foldable[$name].size") {
-    forAll { (fa: F[Int]) =>
-      fa.size should === (iterator(fa).size.toLong)
+  test(s"Foldable[$name].size/get") {
+    forAll { (fa: F[Int], n: Int) =>
+      val s = fa.size
+      s should === (iterator(fa).size.toLong)
+      if (n < s && n >= 0) {
+        fa.get(n.toLong) === Some(iterator(fa).take(n + 1).toList.last)
+      } else {
+        fa.get(n.toLong) === None
+      }
     }
   }