Add Task.forkAndForget

monix-eval/shared/src/main/scala/monix/eval/Task.scala

@@ -1092,6 +1092,21 @@ sealed abstract class Task[+A] extends Serializable {
   final def start: Task[Task[A]] =
     TaskStart(this)
 
+  /** Start execution of the source suspended in the `Task` context,
+    * running it in the background and discarding the result.
+    *
+    * Similar to [[start]] after mapping result to Unit. Below law holds:
+    *
+    * {{{
+    *   task.startAndForget <-> task.start.map(_ => ())
+    * }}}
+    *
+    * IMPORTANT - In contrast to [[start]] it does automatic fork,
+    * forcing new async boundary.
+    */
+  final def startAndForget: Task[Unit] =
+    TaskStartAndForget(this)
+
   /** Converts the source `Task` to a `cats.effect.IO` value. */
   final def toIO(implicit s: Scheduler): IO[A] =
     TaskConversions.toIO(this)(s)

monix-eval/shared/src/main/scala/monix/eval/internal/TaskStartAndForget.scala

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2014-2018 by The Monix Project Developers.
+ * See the project homepage at: https://monix.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package monix.eval
+package internal
+
+private[eval] object TaskStartAndForget {
+  /**
+    * Implementation for `Task.startAndForget`.
+    */
+  def apply[A](fa: Task[A]): Task[Unit] =
+    Task.Async[Unit] { (ctx, cb) =>
+      implicit val sc = ctx.scheduler
+      // It needs its own context, its own cancelable
+      val ctx2 = Task.Context(sc, ctx.options)
+      // Starting actual execution of our newly created task forcing new async boundary
+      Task.unsafeStartAsync(fa, ctx2, Callback.empty)
+      // Signal the created Task reference
+      cb.onSuccess(())
+    }
+}

monix-eval/shared/src/test/scala/monix/eval/TaskStartAndForgetSuite.scala

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2014-2018 by The Monix Project Developers.
+ * See the project homepage at: https://monix.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package monix.eval
+
+import cats.laws._
+import cats.laws.discipline._
+
+import scala.util.Success
+
+object TaskStartAndForgetSuite extends BaseTestSuite {
+
+  test("task.startAndForget works") { implicit sc =>
+    check1 { (i: Int) =>
+      var counter = 0
+      val task = Task {
+        counter = i
+        i
+      }
+      task.startAndForget.runAsync
+      sc.tick()
+
+      counter <-> i
+    }
+  }
+
+  test("task.startAndForget is stack safe") { implicit sc =>
+    var task: Task[Any] = Task(1)
+    for (_ <- 0 until 5000) task = task.startAndForget
+    for (_ <- 0 until 5000) task = task.flatMap(_ => Task.unit)
+
+    val f = task.runAsync
+    sc.tick()
+    assertEquals(f.value, Some(Success(())))
+  }
+
+  test("task.startAndForget <-> task.start.map(_ => ())") { implicit sc =>
+    check1 { (task: Task[Int]) =>
+      task.startAndForget <-> task.start.map(_ => ())
+    }
+  }
+}