implement methods for Validated and Ior

Author: johnynek

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

@@ -985,6 +985,55 @@ sealed abstract private[data] class IorInstances0 {
 
       override def map[B, C](fa: A Ior B)(f: B => C): A Ior C =
         fa.map(f)
+
+      override def as[B, C](fa: A Ior B, c: C): A Ior C =
+        fa match {
+          case Ior.Left(_)    => fa.asInstanceOf[A Ior C]
+          case Ior.Right(_)   => Ior.Right(c)
+          case Ior.Both(a, _) => Ior.Both(a, c)
+        }
+
+      override def tupleLeft[B, C](fa: A Ior B, c: C): A Ior (C, B) =
+        fa match {
+          case Ior.Left(_)    => fa.asInstanceOf[A Ior (C, B)]
+          case Ior.Right(b)   => Ior.Right((c, b))
+          case Ior.Both(a, b) => Ior.Both(a, (c, b))
+        }
+
+      override def tupleRight[B, C](fa: A Ior B, c: C): A Ior (B, C) =
+        fa match {
+          case Ior.Left(_)    => fa.asInstanceOf[A Ior (B, C)]
+          case Ior.Right(b)   => Ior.Right((b, c))
+          case Ior.Both(a, b) => Ior.Both(a, (b, c))
+        }
+
+      override def fproduct[B, C](fa: A Ior B)(f: B => C): A Ior (B, C) =
+        fa match {
+          case Ior.Left(_)    => fa.asInstanceOf[A Ior (B, C)]
+          case Ior.Right(b)   => Ior.Right((b, f(b)))
+          case Ior.Both(a, b) => Ior.Both(a, (b, f(b)))
+        }
+
+      override def fproductLeft[B, C](fa: A Ior B)(f: B => C): A Ior (C, B) =
+        fa match {
+          case Ior.Left(_)    => fa.asInstanceOf[A Ior (C, B)]
+          case Ior.Right(b)   => Ior.Right((f(b), b))
+          case Ior.Both(a, b) => Ior.Both(a, (f(b), b))
+        }
+
+      override def unzip[B, C](fab: A Ior (B, C)): (A Ior B, A Ior C) =
+        fab match {
+          case Ior.Left(a)         => (Ior.Left(a), Ior.Left(a))
+          case Ior.Right((b, c))   => (Ior.Right(b), Ior.Right(c))
+          case Ior.Both(a, (b, c)) => (Ior.Both(a, b), Ior.Both(a, c))
+        }
+
+      override def void[B](fa: A Ior B): A Ior Unit =
+        fa match {
+          case Ior.Left(_)    => fa.asInstanceOf[A Ior Unit]
+          case Ior.Right(_)   => Ior.Right(())
+          case Ior.Both(a, _) => Ior.Both(a, ())
+        }
     }
 
   implicit def catsDataEqForIor[A: Eq, B: Eq]: Eq[A Ior B] = _ === _

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

@@ -1008,6 +1008,36 @@ sealed abstract private[data] class ValidatedInstances2 {
       override def map[A, B](fa: Validated[E, A])(f: (A) => B): Validated[E, B] =
         fa.map(f)
 
+      override def as[A, B](fa: Validated[E, A], b: B): Validated[E, B] =
+        fa match {
+          case Valid(_)       => Valid(b)
+          case i @ Invalid(_) => i.asInstanceOf[Validated[E, B]]
+        }
+
+      override def tupleLeft[A, B](fa: Validated[E, A], b: B): Validated[E, (B, A)] =
+        fa match {
+          case Valid(a)       => Valid((b, a))
+          case i @ Invalid(_) => i.asInstanceOf[Validated[E, (B, A)]]
+        }
+
+      override def tupleRight[A, B](fa: Validated[E, A], b: B): Validated[E, (A, B)] =
+        fa match {
+          case Valid(a)       => Valid((a, b))
+          case i @ Invalid(_) => i.asInstanceOf[Validated[E, (A, B)]]
+        }
+
+      override def fproduct[A, B](fa: Validated[E, A])(f: A => B): Validated[E, (A, B)] =
+        fa match {
+          case Valid(a)       => Valid((a, f(a)))
+          case i @ Invalid(_) => i.asInstanceOf[Validated[E, (A, B)]]
+        }
+
+      override def fproductLeft[A, B](fa: Validated[E, A])(f: A => B): Validated[E, (B, A)] =
+        fa match {
+          case Valid(a)       => Valid((f(a), a))
+          case i @ Invalid(_) => i.asInstanceOf[Validated[E, (B, A)]]
+        }
+
       override def reduceLeftToOption[A, B](fa: Validated[E, A])(f: A => B)(g: (B, A) => B): Option[B] =
         fa.map(f).toOption
 
@@ -1052,6 +1082,13 @@ sealed abstract private[data] class ValidatedInstances2 {
           case _        => Nil
         }
 
+      override def unzip[A, B](fab: Validated[E, (A, B)]): (Validated[E, A], Validated[E, B]) =
+        fab match {
+          case Valid((a, b))  => (Valid(a), Valid(b))
+          case i @ Invalid(_) =>
+            (i.asInstanceOf[Validated[E, A]], i.asInstanceOf[Validated[E, B]])
+        }
+
       override def isEmpty[A](fa: Validated[E, A]): Boolean = fa.isInvalid
 
       override def void[A](fa: Validated[E, A]): Validated[E, Unit] =