Bracket for Task/Coeval, Task.cancelable and Task.onCancelRaiseError by alexandru · Pull Request #561 · monix/monix

alexandru · 2018-01-23T07:35:54Z

Introducing:

task.cancelable for activating the auto-cancelable run-loop for a certain task
task.onCancelRaiseError for throwing an error in case the source task gets cancelled, in a thread-safe way
task.bracket and task.bracketE for resource handling

Bracket

The bracket operation would be the equivalent of try {} finally {} in many mainstream languages.
For both Task and Coeval it comes in two flavors. One would be the simple version:

import java.io._

def readFile(file: File): Task[String] = {
  // Opening a file handle for reading text
  val acquire = Task.eval(new BufferedReader(
    new InputStreamReader(new FileInputStream(file), "utf-8"))
  )

  acquire.bracket { in =>
    // Usage part
    Task.eval {
      // Yes, ugly Java, non-FP loop;
      // side-effects are suspended though
      var line: String = null
      val buff = new StringBuilder()
      do {
        line = in.readLine()
        if (line != null) buff.append(line)
      } while (line != null)
      buff.toString()
    }
  } { in =>
    // The release part
    Task.eval(in.close())
  }
}

And bracketE which allows distinguishing between successful termination, termination in error or, in the case of Task, cancellation:

def readFile(file: File): Task[String] = {
  // Opening a file handle for reading text
  val acquire = Task.eval(new BufferedReader(
    new InputStreamReader(new FileInputStream(file), "utf-8"))
  )

  acquire.bracketE { in =>
    // Usage part
    Task.eval {
      // Yes, ugly Java, non-FP loop;
      // side-effects are suspended though
      var line: String = null
      val buff = new StringBuilder()
      do {
        line = in.readLine()
        if (line != null) buff.append(line)
      } while (line != null)
      buff.toString()
    }
  } { (in, result) =>
    // The release part
    Task.eval {
      result match {
        case Right(_) => println("Successful!")
        case Left(Some(e)) => println("Raised error: " + e)
        case Left(None) => println("Canceled!")
      }
      in.close()
    }
  }
}

Also see the discussion at: typelevel/cats-effect#113

task.onCancelRaiseError

In Monix normally tasks are non-terminating on cancellation. This method transforms a task into one that terminates with error on completion:

import java.util.concurrent.CancellationException

val tenSecs = Task.sleep(10.seconds)
  .onCancelRaiseError(new CancellationException)

val task = tenSecs.fork.flatMap { fa =>
  // Triggering pure cancellation, then trying to get its result
  fa.cancel.flatMap(_ => fa)
}

task.cancelable

This is the opposite of uncancelable, activating "auto-cancelable flatMap chains" for the given task on evaluation. Consider this loop that calculates the n-th Fibonacci number:

def fib(n: Int): Task[Long] = {
  def loop(n: Int, a: Long, b: Long): Task[Long] =
    Task.suspend {
      if (n > 0)
        loop(n - 1, b, a + b)
      else
        Task.now(a)
    }

  loop(n, 0, 1).cancelable
}

By specifying cancelable on the loop, we are ensuring that the internal cancellation flag is checked on asynchronous boundaries, automatically interrupting the evaluation if needed.

LukaJCB · 2018-01-23T09:37:28Z

+    *        as input the resource that needs that needs release, along with
+    *        the result of `use` (cancellation, error or successful result)
+    */
+  final def bracketE[B](use: A => Task[B])(release: (A, Either[Option[Throwable], B]) => Task[Unit]): Task[B] =


Just to be 100% clear, Either[Option[Throwable], B] here means, that
Left(None) is cancelled,
Left(Some(ex)) is an error, and
Right(b) is success, correct? :)

Yes. I'm also waiting on that ADT defined in cats-effect, for whenever it will happen, to introduce another overload.

oleg-py · 2018-01-23T10:05:20Z

+    *
+    * For those cases you might want to do synchronization (e.g. usage of
+    * locks and semaphores) and you might want to use [[bracketE]], the
+    * version that allows you to differentiate between nuormal termination


Typo: nuormal 😛

oleg-py · 2018-01-23T10:05:41Z

+    *         if (n > 0)
+    *           loop(n - 1, b, a + b)
+    *         else
+    *           a


Shouldn't it be Task.now(a)?

oleg-py · 2018-01-23T10:06:23Z

+    * {{{
+    *   Task(println("Hello ..."))
+    *     .cancelable
+    *     .flatMap(_ => println("World!"))


I think println needs to be wrapped in Task

oleg-py · 2018-01-23T10:09:04Z

+    * {{{
+    *   import java.util.concurrent.CancellationException
+    *
+    *   val tenSecs = Task.sleep(10.seconds).onCancelRaiseError


Forgotten parameter for onCancelRaiseError

oleg-py · 2018-01-23T10:14:39Z

+    acquire.flatMap { a =>
+      val next = try use(a) catch { case NonFatal(e) => Task.raiseError(e) }
+      next.onCancelRaiseError(isCancel).transformWith[B](
+        b => release(a, Right(b)).map(_ => b),


So as I understand that correctly, if release throws or return a failed task, it will shadow the exception from use. Maybe it should use reportFailure from current scheduler instead?

oleg-py · 2018-01-24T14:56:23Z

My last comment got hidden, but it kinda was important: what happens if both use and release result in a failure?

codecov · 2018-01-24T15:32:36Z

Codecov Report

Merging #561 into master will increase coverage by 0.06%.
The diff coverage is 98.33%.

@@            Coverage Diff            @@
##           master    #561      +/-   ##
=========================================
+ Coverage   90.53%   90.6%   +0.06%     
=========================================
  Files         367     369       +2     
  Lines        9742    9782      +40     
  Branches     1838    1841       +3     
=========================================
+ Hits         8820    8863      +43     
+ Misses        922     919       -3

alexandru · 2018-01-25T07:48:09Z

@oleg-py that's a very good point.

I added a detailed reply here: typelevel/cats-effect#113 (comment)

Currently the behavior, if both use and release throw, is this:

the error sent downstream is the one in release
the other error is completely silent

I'll modify the behavior to be consistent with the one in Haskell, that I just tested:

the error sent downstream should be the one in use
the error in release should be reported using Scheduler.reportError

alexandru · 2018-01-25T09:27:06Z

@oleg-py I have implemented the changes.

alexandru · 2018-01-25T11:11:43Z

@oleg-py given your involvement in bracket, I'd really like your approval for merging this PR.

So what say you? Does it look good after the latest changes?

UPDATE: corrected the username

alexandru · 2018-01-25T12:06:33Z

Oh, above I misspelled the name, sorry @olafurpg, I wanted to mention @oleg-py, both of you have usernames starting with "ol" 😜

oleg-py · 2018-01-25T13:34:53Z

@alexandru looks great 👍

ngbinh · 2018-01-25T16:00:27Z

wow! This is awesome!

olafurpg · 2018-01-26T16:42:56Z

bracket looks amazing, looking forward to give it a try!

alexandru added 2 commits January 23, 2018 00:15

Add bracket & stuff

7f8a69d

ScalaDoc for TaskBracket

17faacc

alexandru added the enhancement label Jan 23, 2018

alexandru added this to the 3.0.0 milestone Jan 23, 2018

LukaJCB reviewed Jan 23, 2018

View reviewed changes

oleg-py reviewed Jan 23, 2018

View reviewed changes

alexandru added 2 commits January 23, 2018 18:35

Add Task.bracket tests

a393ed5

Coeval.bracket, update ScalaDoc, fix tests

e37b365

onCancelRaiseError reports errors are cancel

2ab1912

alexandru changed the title ~~WIP: Task.cancelable, Task.onCancelRaiseError and Task.bracket~~ Bracket for Task/Coeval, Task.cancelable and Task.onCancelRaiseError Jan 24, 2018

Fix ScalaDoc

9152a69

Signal error in "use", when both it and "release" throw

b4d453a

alexandru mentioned this pull request Jan 25, 2018

Add Bracket type class typelevel/cats-effect#113

Merged

Correct typo

e7130ea

alexandru merged commit 827d2cc into monix:master Jan 25, 2018

Navigation Menu

Repository navigation

Bracket for Task/Coeval, Task.cancelable and Task.onCancelRaiseError - #561

Bracket for Task/Coeval, Task.cancelable and Task.onCancelRaiseError#561
alexandru merged 8 commits into
monix:masterfrom
alexandru:task-auto-cancel

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

Conversation

Uh oh!

Bracket

task.onCancelRaiseError

task.cancelable

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Codecov Report

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants