Add Scalaz & Cats instances for AsyncCallback

Author: japgolly

cats/src/main/scala/japgolly/scalajs/react/internal/CatsReactInstances.scala

@@ -9,7 +9,8 @@ import japgolly.scalajs.react.extra._
 trait CatsReactInstances {
 
   implicit final lazy val reactCallbackCatsInstance: MonadError[CallbackTo, Throwable] = new MonadError[CallbackTo, Throwable] {
-    override def pure[A](x: A): CallbackTo[A] = CallbackTo.pure(x)
+    override def pure[A](x: A): CallbackTo[A] =
+      CallbackTo.pure(x)
 
     override def map[A, B](fa: CallbackTo[A])(f: A => B): CallbackTo[B] =
       fa.map(f)
@@ -30,6 +31,39 @@ trait CatsReactInstances {
       }
   }
 
+  implicit final lazy val reactAsyncCallbackCatsInstance: MonadError[AsyncCallback, Throwable] = new MonadError[AsyncCallback, Throwable] {
+
+    override def pure[A](x: A): AsyncCallback[A] =
+      AsyncCallback.pure(x)
+
+    override def ap[A, B](ff: AsyncCallback[A => B])(fa: AsyncCallback[A]) =
+      ff.zipWith(fa)(_(_))
+
+    override def ap2[A, B, Z](ff: AsyncCallback[(A, B) => Z])(fa: AsyncCallback[A], fb: AsyncCallback[B]) =
+      ff.zipWith(fa.zip(fb))(_.tupled(_))
+
+    override def map2[A, B, Z](fa: AsyncCallback[A], fb: AsyncCallback[B])(f: (A, B) => Z) =
+      fa.zipWith(fb)(f)
+
+    override def map[A, B](fa: AsyncCallback[A])(f: A => B): AsyncCallback[B] =
+      fa.map(f)
+
+    override def flatMap[A, B](fa: AsyncCallback[A])(f: A => AsyncCallback[B]): AsyncCallback[B] =
+      fa.flatMap(f)
+
+    override def tailRecM[A, B](a: A)(f: A => AsyncCallback[Either[A, B]]): AsyncCallback[B] =
+      AsyncCallback.tailrec(a)(f)
+
+    override def raiseError[A](e: Throwable): AsyncCallback[A] =
+      AsyncCallback(throw e)
+
+    override def handleErrorWith[A](fa: AsyncCallback[A])(f: Throwable => AsyncCallback[A]): AsyncCallback[A] =
+      fa.attempt.flatMap {
+        case Right(a) => AsyncCallback pure a
+        case Left(t)  => f(t)
+      }
+    }
+
   implicit final lazy val reactCallbackOptionCatsInstance: Monad[CallbackOption] = new Monad[CallbackOption] {
     override def pure[A](x: A): CallbackOption[A] = CallbackOption.pure(x)
 

core/src/main/scala/japgolly/scalajs/react/AsyncCallback.scala

@@ -113,6 +113,15 @@ object AsyncCallback {
 
   @inline implicit def asynCallbackCovariance[A, B >: A](c: AsyncCallback[A]): AsyncCallback[B] =
     c.widen
+
+  /** Not literally tail-recursive because AsyncCallback is continuation-based, but this utility in this shape may still
+    * be useful.
+    */
+  def tailrec[A, B](a: A)(f: A => AsyncCallback[Either[A, B]]): AsyncCallback[B] =
+    f(a).flatMap {
+      case Left(a2) => tailrec(a2)(f)
+      case Right(b) => pure(b)
+    }
 }
 
 /** Pure asynchronous callback.

scalaz-7.2/src/main/scala/japgolly/scalajs/react/internal/ScalazReactInstances.scala

@@ -38,6 +38,40 @@ trait ScalazReactInstances {
         }
     }
 
+  implicit final lazy val reactAsyncCallbackScalazInstance: MonadError[AsyncCallback, Throwable] with BindRec[AsyncCallback] =
+    new MonadError[AsyncCallback, Throwable] with BindRec[AsyncCallback] {
+
+      override def point[A](a: => A): AsyncCallback[A] =
+        AsyncCallback.point(a)
+
+      override def ap[A, B](fa: => AsyncCallback[A])(f: => AsyncCallback[A => B]) =
+        f.zipWith(fa)(_(_))
+
+      override def ap2[A, B, C](fa: => AsyncCallback[A], fb: => AsyncCallback[B])(f: AsyncCallback[(A, B) => C]) =
+        f.zipWith(fa.zip(fb))(_.tupled(_))
+
+      override def apply2[A, B, C](fa: => AsyncCallback[A], fb: => AsyncCallback[B])(f: (A, B) => C) =
+        fa.zipWith(fb)(f)
+
+      override def bind[A, B](fa: AsyncCallback[A])(f: A => AsyncCallback[B]): AsyncCallback[B] =
+        fa >>= f
+
+      override def map[A, B](fa : AsyncCallback[A])(f : A => B): AsyncCallback[B] =
+        fa map f
+
+      override def tailrecM[A, B](f: A => AsyncCallback[A \/ B])(a: A): AsyncCallback[B] =
+        AsyncCallback.tailrec(a)(f.andThen(_.map(_.toEither)))
+
+      override def raiseError[A](e: Throwable): AsyncCallback[A] =
+        AsyncCallback.throwException(e)
+
+      override def handleError[A](fa: AsyncCallback[A])(f: Throwable => AsyncCallback[A]): AsyncCallback[A] =
+        fa.attempt.flatMap {
+          case Right(a) => AsyncCallback pure a
+          case Left(t)  => f(t)
+        }
+    }
+
   implicit final lazy val reactCallbackOptionScalazInstance: MonadPlus[CallbackOption] with BindRec[CallbackOption] =
     new MonadPlus[CallbackOption] with BindRec[CallbackOption] {
       override def point[A](a: => A): CallbackOption[A] =