Add ability to fork AsyncCallbacks

Closes #819

Author: japgolly

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

@@ -220,6 +220,8 @@ object AsyncCallback {
       promise
     }
   }
+
+  final case class Forked[A](await: AsyncCallback[A], isComplete: CallbackTo[Boolean])
 }
 
 /** Pure asynchronous callback.
@@ -252,7 +254,7 @@ object AsyncCallback {
   *
   * @tparam A The type of data asynchronously produced on success.
   */
-final class AsyncCallback[A] private[AsyncCallback] (val completeWith: (Try[A] => Callback) => Callback) extends AnyVal {
+final class AsyncCallback[A] private[AsyncCallback] (val completeWith: (Try[A] => Callback) => Callback) extends AnyVal { self =>
 
   @inline def underlyingRepr = completeWith
 
@@ -704,4 +706,26 @@ final class AsyncCallback[A] private[AsyncCallback] (val completeWith: (Try[A] =
     */
   @inline def finallyRunSync[B](runFinally: CallbackTo[B]): AsyncCallback[A] =
     finallyRun(runFinally.asAsyncCallback)
+
+  /** Runs this async computation in the background.
+    *
+    * Returns the ability for you to await/join the forked computation.
+    */
+  def fork: CallbackTo[AsyncCallback.Forked[A]] =
+    AsyncCallback.promise[A].flatMap { case (promise, completePromise) =>
+      var _complete    = false
+      val isComplete   = CallbackTo(_complete)
+      val markComplete = CallbackTo { _complete = true }
+      val runInBg      = self.attemptTry.finallyRunSync(markComplete).flatMapSync(completePromise).fork_
+      val forked       = AsyncCallback.Forked(promise, isComplete)
+      runInBg.ret(forked)
+    }
+
+  /** Runs this async computation in the background.
+    *
+    * Unlike [[fork]] this returns nothing, meaning this is like fire-and-forget.
+    */
+  def fork_ : Callback =
+    delayMs(1).toCallback
+
 }

doc/changelog/1.7.7.md

@@ -2,6 +2,15 @@
 
 This entire release is focused on `AsyncCallback`.
 
+* `AsyncCallback` instances
+
+  * Added `fork` and `fork_` which run the async computation in the background.
+
+    The result of `fork` gives you access to `await: AsyncCallback[A], isComplete: CallbackTo[Boolean]` which you can
+    use to join back up with it again later.
+
+    `fork_` on the other hand, returns nothing and is effectively fire-and-forget.
+
 * `AsyncCallback.Barrier`:
 
   * Added `isComplete: CallbackTo[Boolean]` to synchronously query whether the barrier is complete or not.

test/src/test/scala/japgolly/scalajs/react/core/AsyncCallbackTest.scala

@@ -17,6 +17,15 @@ object AsyncCallbackTest extends TestSuite {
     def apply(s: String) = Callback { this += s }
   }
 
+  private final val asyncTestTimeout = 2000
+
+  private def asyncTest[A](ac: AsyncCallback[A]): Future[A] = {
+    ac.timeoutMs(asyncTestTimeout).map {
+      case Some(a) => a
+      case None    => fail(s"Async test timed out after ${asyncTestTimeout / 1000} sec.")
+    }.unsafeToFuture()
+  }
+
   override def tests = Tests {
 
     "fromCallback" - {
@@ -144,5 +153,16 @@ object AsyncCallbackTest extends TestSuite {
       assertEq(i, 2)
     }
 
+    "fork" - asyncTest {
+      for {
+        (task, completeTask) <- AsyncCallback.promise[Int].asAsyncCallback
+        forked               <- task.fork.asAsyncCallback
+        _                    <- forked.isComplete.asAsyncCallback.tap(assertEq(_, false))
+        _                    <- completeTask(Success(123)).asAsyncCallback
+        _                    <- forked.await.tap(assertEq(_, 123))
+        _                    <- forked.isComplete.asAsyncCallback.tap(assertEq(_, true))
+      } yield ()
+    }
+
   }
 }