A TaskLocal is like a ThreadLocal that is pure and with a flexible scope, being processed in the context of the Task data type.

This data type wraps monix.execution.misc.Local.

Just like a ThreadLocal, usage of a TaskLocal is safe, the state of all current locals being transported over async boundaries (aka when threads get forked) by the Task run-loop implementation, but only when the Task reference gets executed with Task.Options.localContextPropagation set to true.

One way to achieve this is with Task.executeWithOptions, a single call is sufficient just before runAsync:

import monix.execution.Scheduler.Implicits.global

val t = Task(42)
t.executeWithOptions(_.enableLocalContextPropagation)
  // triggers the actual execution
  .runToFuture

Another possibility is to use Task.runToFutureOpt or Task.runToFutureOpt instead of runAsync and specify the set of options implicitly:

{
  implicit val options = Task.defaultOptions.enableLocalContextPropagation

  // Options passed implicitly
  val f = t.runToFutureOpt
}

Full example:

import monix.eval.{Task, TaskLocal}

val task: Task[Unit] =
  for {
    local <- TaskLocal(0)
    value1 <- local.read // value1 == 0
    _ <- local.write(100)
    value2 <- local.read // value2 == 100
    value3 <- local.bind(200)(local.read.map(_ * 2)) // value3 == 200 * 2
    value4 <- local.read // value4 == 100
    _ <- local.clear
    value5 <- local.read // value5 == 0
  } yield {
    // Should print 0, 100, 400, 100, 0
    println("value1: " + value1)
    println("value2: " + value2)
    println("value3: " + value3)
    println("value4: " + value4)
    println("value5: " + value5)
  }

// For transporting locals over async boundaries defined by
// Task, any Scheduler will do, however for transporting locals
// over async boundaries managed by Future and others, you need
// a `TracingScheduler` here:
import monix.execution.Scheduler.Implicits.global

// Needs enabling the "localContextPropagation" option
// just before execution
implicit val opts = Task.defaultOptions.enableLocalContextPropagation

// Triggering actual execution
val result = task.runToFutureOpt