Implement several Functor methods to avoid using map when not needed

Author: johnynek

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

@@ -77,6 +77,36 @@ trait EitherInstances extends cats.kernel.instances.EitherInstances {
       override def map[B, C](fa: Either[A, B])(f: B => C): Either[A, C] =
         fa.map(f)
 
+      override def as[B, C](fa: Either[A, B], c: C): Either[A, C] =
+        fa match {
+          case Right(_)    => Right(c)
+          case left @ Left(_) => left.rightCast[C]
+        }
+
+      override def tupleLeft[B, C](fa: Either[A, B], c: C): Either[A, (C, B)] =
+        fa match {
+          case Right(b)       => Right((c, b))
+          case left @ Left(_) => left.rightCast[(C, B)]
+        }
+
+      override def tupleRight[B, C](fa: Either[A, B], c: C): Either[A, (B, C)] =
+        fa match {
+          case Right(b)       => Right((b, c))
+          case left @ Left(_) => left.rightCast[(B, C)]
+        }
+
+      override def fproduct[B, C](fa: Either[A, B])(f: B => C): Either[A, (B, C)] =
+        fa match {
+          case Right(b)       => Right((b, f(b)))
+          case left @ Left(_) => left.rightCast[(B, C)]
+        }
+
+      override def fproductLeft[B, C](fa: Either[A, B])(f: B => C): Either[A, (C, B)] =
+        fa match {
+          case Right(b)       => Right((f(b), b))
+          case left @ Left(_) => left.rightCast[(C, B)]
+        }
+
       @tailrec
       def tailRecM[B, C](b: B)(f: B => Either[A, Either[B, C]]): Either[A, C] =
         f(b) match {
@@ -210,6 +240,12 @@ trait EitherInstances extends cats.kernel.instances.EitherInstances {
             }
         }
 
+      override def unzip[B, C](fab: Either[A, (B, C)]): (Either[A, B], Either[A, C]) =
+        fab match {
+          case Right((b, c))  => (Right(b), Right(c))
+          case left @ Left(_) => (left.rightCast[B], left.rightCast[C])
+        }
+
       override def void[B](e: Either[A, B]): Either[A, Unit] =
         if (e.isRight) Either.unit
         else e.asInstanceOf[Either[A, Unit]] // it is Left(a)

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

@@ -203,6 +203,9 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
       override def zipWithIndex[A](fa: List[A]): List[(A, Int)] =
         fa.zipWithIndex
 
+      override def unzip[A, B](fab: List[(A, B)]): (List[A], List[B]) =
+        fab.unzip
+
       override def partitionEither[A, B, C](
         fa: List[A]
       )(f: A => Either[B, C])(implicit A: Alternative[List]): (List[B], List[C]) =

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

@@ -59,6 +59,18 @@ trait MapInstances extends cats.kernel.instances.MapInstances {
       override def map[A, B](fa: Map[K, A])(f: A => B): Map[K, B] =
         fa.map { case (k, a) => (k, f(a)) }
 
+      override def unzip[A, B](fab: Map[K, (A, B)]): (Map[K, A], Map[K, B]) = {
+        val leftBuilder = Map.newBuilder[K, A]
+        val rightBuilder = Map.newBuilder[K, B]
+        leftBuilder.sizeHint(fab.size)
+        rightBuilder.sizeHint(fab.size)
+        fab.foreach { case (k, (a, b)) =>
+          leftBuilder += k -> a
+          rightBuilder += k -> b
+        }
+        (leftBuilder.result(), rightBuilder.result())
+      }
+
       override def map2[A, B, Z](fa: Map[K, A], fb: Map[K, B])(f: (A, B) => Z): Map[K, Z] =
         if (fb.isEmpty) Map.empty // do O(1) work if fb is empty
         else fa.flatMap { case (k, a) => fb.get(k).map(b => (k, f(a, b))) }

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

@@ -77,6 +77,33 @@ trait OptionInstances extends cats.kernel.instances.OptionInstances {
       override def map[A, B](fa: Option[A])(f: A => B): Option[B] =
         fa.map(f)
 
+      override def as[A, B](fa: Option[A], b: B): Option[B] =
+        if (fa.isDefined) Some(b) else None
+
+      override def tupleLeft[A, B](fa: Option[A], b: B): Option[(B, A)] =
+        fa match {
+          case Some(a) => Some((b, a))
+          case None    => None
+        }
+
+      override def tupleRight[A, B](fa: Option[A], b: B): Option[(A, B)] =
+        fa match {
+          case Some(a) => Some((a, b))
+          case None    => None
+        }
+
+      override def fproduct[A, B](fa: Option[A])(f: A => B): Option[(A, B)] =
+        fa match {
+          case Some(a) => Some((a, f(a)))
+          case None    => None
+        }
+
+      override def fproductLeft[A, B](fa: Option[A])(f: A => B): Option[(B, A)] =
+        fa match {
+          case Some(a) => Some((f(a), a))
+          case None    => None
+        }
+
       def flatMap[A, B](fa: Option[A])(f: A => Option[B]): Option[B] =
         fa.flatMap(f)
 
@@ -244,6 +271,12 @@ trait OptionInstances extends cats.kernel.instances.OptionInstances {
           case (Some(a), Some(b)) => Some(f(Ior.both(a, b)))
         }
 
+      override def unzip[A, B](fab: Option[(A, B)]): (Option[A], Option[B]) =
+        fab match {
+          case Some((a, b)) => (Some(a), Some(b))
+          case None         => (None, None)
+        }
+
       override def unit: Option[Unit] = someUnit
       override def void[A](oa: Option[A]): Option[Unit] =
         if (oa.isDefined) someUnit else None

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

@@ -189,6 +189,9 @@ trait QueueInstances extends cats.kernel.instances.QueueInstances {
 
       override def toIterable[A](fa: Queue[A]): Iterable[A] = fa
 
+      override def unzip[A, B](fab: Queue[(A, B)]): (Queue[A], Queue[B]) =
+        fab.unzip
+
       override def reduceLeftOption[A](fa: Queue[A])(f: (A, A) => A): Option[A] =
         fa.reduceLeftOption(f)
 

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

@@ -150,6 +150,9 @@ trait SeqInstances extends cats.kernel.instances.SeqInstances {
       override def zipWithIndex[A](fa: Seq[A]): Seq[(A, Int)] =
         fa.zipWithIndex
 
+      override def unzip[A, B](fab: Seq[(A, B)]): (Seq[A], Seq[B]) =
+        fab.unzip
+
       override def exists[A](fa: Seq[A])(p: A => Boolean): Boolean =
         fa.exists(p)
 

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

@@ -78,6 +78,19 @@ trait SortedMapInstances extends SortedMapInstances2 {
         fa.map { case (k, a) => (k, f(a)) }
       }
 
+      override def unzip[A, B](fab: SortedMap[K, (A, B)]): (SortedMap[K, A], SortedMap[K, B]) = {
+        implicit val ordering: Ordering[K] = fab.ordering
+        val leftBuilder = SortedMap.newBuilder[K, A](ordering)
+        val rightBuilder = SortedMap.newBuilder[K, B](ordering)
+        leftBuilder.sizeHint(fab.size)
+        rightBuilder.sizeHint(fab.size)
+        fab.foreach { case (k, (a, b)) =>
+          leftBuilder += k -> a
+          rightBuilder += k -> b
+        }
+        (leftBuilder.result(), rightBuilder.result())
+      }
+
       override def map2Eval[A, B, Z](
         fa: SortedMap[K, A],
         fb: Eval[SortedMap[K, B]]

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

@@ -218,6 +218,9 @@ trait VectorInstances extends cats.kernel.instances.VectorInstances {
 
       override def algebra[A]: Monoid[Vector[A]] = kernel.instances.VectorMonoid[A]
 
+      override def unzip[A, B](fab: Vector[(A, B)]): (Vector[A], Vector[B]) =
+        fab.unzip
+
       def functor: Functor[Vector] = this
 
       def align[A, B](fa: Vector[A], fb: Vector[B]): Vector[A Ior B] = {

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

@@ -109,6 +109,12 @@ package object cats {
         }
       override def distribute[F[_], A, B](fa: F[A])(f: A => B)(implicit F: Functor[F]): Id[F[B]] = F.map(fa)(f)
       override def map[A, B](fa: A)(f: A => B): B = f(fa)
+      override def as[A, B](fa: A, b: B): B = b
+      override def tupleLeft[A, B](fa: A, b: B): (B, A) = (b, fa)
+      override def tupleRight[A, B](fa: A, b: B): (A, B) = (fa, b)
+      override def fproduct[A, B](fa: A)(f: A => B): (A, B) = (fa, f(fa))
+      override def fproductLeft[A, B](fa: A)(f: A => B): (B, A) = (f(fa), fa)
+      override def unzip[A, B](fab: (A, B)): (A, B) = fab
       override def ap[A, B](ff: A => B)(fa: A): B = ff(fa)
       override def flatten[A](ffa: A): A = ffa
       override def map2[A, B, Z](fa: A, fb: B)(f: (A, B) => Z): Z = f(fa, fb)