How to combine Alts into new ones about hopac HOT 2 CLOSED

First question first. The current signature of >>=? is

val (>>=?): Alt<'x> -> ('x -> Job<'y>) -> Alt<'y>

And Alt<'x> is a subtype of Job<'x>. So, you can use upcast:

let rec accum sum =
    Alt.choose [ Ch.Alt.take addCh >>=? fun x -> upcast accum (sum + x)
                 Ch.Alt.take subCh >>=? fun x -> upcast accum (sum - x)
                 Ch.Alt.give readCh sum >>=? fun _ -> upcast accum sum ]

Ideally F# would upcast implicitly. It would be possible to change the signature of >>=? to

val (>>=?): Alt<'x> -> ('x -> #Job<'y>) -> Alt<'y>

In fact, many combinators could be changed similarly. I think the reasons as to why this wasn't done initially are historical: I didn't initially use subtyping/inheritance. Using the above kind of bounded quantification at covariant positions would likely reduce the overall need for upcasts, but it does not eliminate the need completely (e.g. match where different cases return different subtypes).

from hopac.

Second question. In Hopac, the job monad serves two purposes:

• it represents a thread of execution that can be suspended without blocking native threads (like async), and
• inside the job monad there is efficient access to the scheduling infrastructure, allowing operations such as resuming another job (e.g. when a message is passed to a waiting job) to be performed efficiently.

Of the above, the first one is essential, while the second one is nice for performance. In Concurrent ML, the first feature is essentially a part of the language implementation, so there is no need for a monadic encoding of suspendable threads. In F# we don't have built-in lightweight continuations or threads, so Hopac uses the job monad.

Monadic encodings like the ones used by async and job are not the only ways to encode suspendable threads of execution, but they have some nice properties.

from hopac.