What are the semantics of attempt + cancellation?

[natefaubion]

If I have this code:

do
  canceler <- forkAff do
    res <- attempt do
      delay (Milliseconds 100.0)
      pure unit
    case res of
      Left err -> logShow error
      Right _  -> log "Done"
  delay (Milliseconds 10.0)
  canceled <- cancel canceler (error "Stop!")
  when canceled do
    log "Canceled"

What should this log? Should attempt mask a cancellation attempt, and prevent cancellation?

[natefaubion]

Cancellation is an asynchronous exception. It's as if an exception was raised within the thread. attempt is just substitution that also catches exceptions within that block. So if I throw an asynchronous exception during an attempt, shouldn't it be caught?

[jdegoes]

attempt inside the child process cannot (or rather, must not) prevent cancellation. Cancellation occurs at the parent's request and cannot be "caught" inside the child. The child can catch it's own mistakes, but cannot prevent its own cancellation. I wouldn't be surprised if that's broken now.

My newer design for this, which I have implemented in Scala, is that fork :: forall e a. Aff e a -> Aff e (Thread e a) returns a record containing two things:

type Thread e a = { kill : Throwable -> Aff e Unit, join : Aff e a }

Where join awaits the completion of the child process and returns its computed value. This allows you to rethrow the kill exception to join — meaning if some process is joining the forked thread, but the forked thread is killed with some exception e, then the join function will throw e to the process joining the forked thread.

[natefaubion]

Yes, I was just thinking about implementing join earlier today.

[natefaubion]

I also I think, given a join operation and a functional dependency, you could write a MonadFork class with sensible laws.

[jdegoes]

I also I think, given a join operation and a functional dependency, you could write a MonadFork class with sensible laws.

Agreed, fork-join as a pair enable sensible laws for a MonadFork class, with kill in some subclass.

[natefaubion]

class (Monad m, Functor t) <= MonadFork m t | m -> t, t <- m where
  fork :: forall a. m a -> m (t a)
  join :: forall a. t a -> m a

Which is very similar to Parallel:

class (Monad m, Applicative f) <= Parallel f m | m -> f, f -> m where
  parallel   :: m ~> f
  sequential :: f ~> m

[jdegoes]

Looks great! 👍