Convert an action in mato an action in IO.

Convert an action in mato an action in IO.

Map the underlying IO monad

Embeds the IO monad into the M〈A〉 monad. NOTE: This will fail if the monad transformer stack doesn't have an IO monad as its innermost monad.

Embeds the IO monad into the M〈A〉 monad. NOTE: This will fail if the monad transformer stack doesn't have an IO monad as its innermost monad.

Get the IO monad from within the M monad

This only works if the M trait implements MonadIO.ToIO.

Map the underlying IO monad

Lifts the IO monad into a monad transformer stack.

If this method isn't overloaded in the inner monad or any monad in the stack on the way to the inner monad then it will throw an exception.

This isn't ideal - however it appears to be the only way to achieve this kind of functionality in C# without resorting to magic.

Lifts the IO monad into a monad transformer stack.

If this method isn't overloaded in the inner monad or any monad in the stack on the way to the inner monad then it will throw an exception.

This isn't ideal - however it appears to be the only way to achieve this kind of functionality in C# without resorting to magic.

Extract the IO monad from within the M monad (usually as part of a monad-transformer stack).

Extract the IO monad from within the M monad (usually as part of a monad-transformer stack). Then perform a mapping operation on the IO action before lifting the IO back into the M monad.

Creates a local cancellation environment

A local cancellation environment stops other IO computations, that rely on the same environmental cancellation token, from being taken down by a regional cancellation.

If a IO.cancel is invoked locally then it will still create an exception that propagates upwards and so catching cancellations is still important.

Make this IO computation run on the SynchronizationContext that was captured at the start of the IO chain (i.e. the one embedded within the EnvIO environment that is passed through all IO computations)

Await a forked operation

Queue this IO operation to run on the thread-pool.

Timeout operation if it takes too long

The IO monad tracks resources automatically, this creates a local resource environment to run this computation in. Once the computation has completed any resources acquired are automatically released. Imagine this as the ultimate using statement.

When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage the acquisition and releasing, taking a function of the acquired value that specifies an action to be performed in between.

When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage the acquisition and releasing, taking a function of the acquired value that specifies an action to be performed in between.

Keeps repeating the computation forever, or until an error occurs

Any resources acquired within a repeated IO computation will automatically be released. This also means you can't acquire resources and return them from within a repeated computation.

Keeps repeating the computation, until the scheduler expires, or an error occurs

Any resources acquired within a repeated IO computation will automatically be released. This also means you can't acquire resources and return them from within a repeated computation.

Keeps repeating the computation until the predicate returns false, or an error occurs

Any resources acquired within a repeated IO computation will automatically be released. This also means you can't acquire resources and return them from within a repeated computation.

Keeps repeating the computation, until the scheduler expires, or the predicate returns false, or an error occurs

Any resources acquired within a repeated IO computation will automatically be released. This also means you can't acquire resources and return them from within a repeated computation.

Keeps repeating the computation until the predicate returns true, or an error occurs

Any resources acquired within a repeated IO computation will automatically be released. This also means you can't acquire resources and return them from within a repeated computation.

Keeps repeating the computation, until the scheduler expires, or the predicate returns true, or an error occurs

Any resources acquired within a repeated IO computation will automatically be released. This also means you can't acquire resources and return them from within a repeated computation.

Retry if the IO computation fails

This variant will retry forever

Any resources acquired within a retrying IO computation will automatically be released if the operation fails. So, successive retries will not grow the acquired resources on each retry iteration. Any successful operation that acquires resources will have them tracked in the usual way.

Retry if the IO computation fails

This variant will retry until the schedule expires

Any resources acquired within a retrying IO computation will automatically be released if the operation fails. So, successive retries will not grow the acquired resources on each retry iteration. Any successful operation that acquires resources will have them tracked in the usual way.

Retry if the IO computation fails

This variant will keep retrying whilst the predicate returns true for the error generated at each iteration; at which point the last raised error will be thrown.

Any resources acquired within a retrying IO computation will automatically be released if the operation fails. So, successive retries will not grow the acquired resources on each retry iteration. Any successful operation that acquires resources will have them tracked in the usual way.

Retry if the IO computation fails

This variant will keep retrying whilst the predicate returns true for the error generated at each iteration; or, until the schedule expires; at which point the last raised error will be thrown.

Any resources acquired within a retrying IO computation will automatically be released if the operation fails. So, successive retries will not grow the acquired resources on each retry iteration. Any successful operation that acquires resources will have them tracked in the usual way.

Retry if the IO computation fails

This variant will keep retrying until the predicate returns true for the error generated at each iteration; at which point the last raised error will be thrown.

Any resources acquired within a retrying IO computation will automatically be released if the operation fails. So, successive retries will not grow the acquired resources on each retry iteration. Any successful operation that acquires resources will have them tracked in the usual way.

Retry if the IO computation fails

This variant will keep retrying until the predicate returns true for the error generated at each iteration; or, until the schedule expires; at which point the last raised error will be thrown.

Any resources acquired within a retrying IO computation will automatically be released if the operation fails. So, successive retries will not grow the acquired resources on each retry iteration. Any successful operation that acquires resources will have them tracked in the usual way.