Control.Future

Similar to async package, however, suitable for manual threading and go without exceptions.

Documentation

data Progress a b

Constructors

Making

Fixme a

Finished b

Instances

Functor (Progress a)

(Show a, Show b) => Show (Progress a b)

newtype Future a b

Two kinds of future is possible: (i) A pile of failures (Monoid a) and (ii) Successful result b.

Constructors

Future

Fields

runFuture :: IO (Progress a b)

Instances

Monoid a => Alternative (Future a)

Monoid a => Monad (Future a)

Functor (Future a)

Monoid a => Applicative (Future a)

type Future' = Future [String]

desire :: MonadIO m => Future a b -> (a -> IO b) -> m b

Wait until future comes, and modify failure history.

waitFor :: MonadIO m => Future a b -> m (Progress a b)

Just wait for the future honestly.

maybeChance :: MonadIO m => Future a b -> (a -> IO b) -> m (Maybe b)

Return Just when it is time. The history may be modified.

getProgress :: MonadIO m => Future a b -> m (Progress a b)

If it is too early, immediately returns Making.

mkFuture :: MonadIO m => ((Progress a b -> IO ()) -> IO ()) -> m (Future a b)

mkFuture $ \updateProgress -> forkIO (doSth >>= updateProgress)

expect :: Show a => Future a b -> IO b

Run Future action immediately.