FRP.BearRiver.Task

Task abstraction on top of signal transformers.

The Task type

data Task m a b c

A task is a partially SF that may terminate with a result.

Instances

Monad m => Applicative (Task m a b)

Defined in FRP.BearRiver.Task

Methods

pure :: a0 -> Task m a b a0

(<*>) :: Task m a b (a0 -> b0) -> Task m a b a0 -> Task m a b b0

liftA2 :: (a0 -> b0 -> c) -> Task m a b a0 -> Task m a b b0 -> Task m a b c

(*>) :: Task m a b a0 -> Task m a b b0 -> Task m a b b0

(<*) :: Task m a b a0 -> Task m a b b0 -> Task m a b a0

Monad m => Functor (Task m a b)

Defined in FRP.BearRiver.Task

Methods

fmap :: (a0 -> b0) -> Task m a b a0 -> Task m a b b0

(<$) :: a0 -> Task m a b b0 -> Task m a b a0

Monad m => Monad (Task m a b)

Defined in FRP.BearRiver.Task

Methods

(>>=) :: Task m a b a0 -> (a0 -> Task m a b b0) -> Task m a b b0

(>>) :: Task m a b a0 -> Task m a b b0 -> Task m a b b0

return :: a0 -> Task m a b a0

mkTask :: Monad m => SF m a (b, Event c) -> Task m a b c

Creates a Task from an SF that returns, as a second output, an Event when the SF terminates. See switch.

runTask :: Monad m => Task m a b c -> SF m a (Either b c)

Runs a task.

The output from the resulting signal transformer is tagged with Left while the underlying task is running. Once the task has terminated, the output goes constant with the value Right x, where x is the value of the terminating event.

runTask_ :: Monad m => Task m a b c -> SF m a b

Runs a task that never terminates.

The output becomes undefined once the underlying task has terminated.

Convenience function for tasks which are known not to terminate.

taskToSF :: Monad m => Task m a b c -> SF m a (b, Event c)

Creates an SF that represents an SF and produces an event when the task terminates, and otherwise produces just an output.

Basic tasks

constT :: Monad m => b -> Task m a b c

Non-terminating task with constant output b.

sleepT :: Monad m => Time -> b -> Task m a b ()

Sleeps for t seconds with constant output b.

snapT :: Monad m => Task m a b a

Takes a "snapshot" of the input and terminates immediately with the input value as the result.

No time passes; therefore, the following must hold:

snapT >> snapT = snapT

Basic tasks combinators

timeOut :: Monad m => Task m a b c -> Time -> Task m a b (Maybe c) infixl 0

Impose a time out on a task.

abortWhen :: Monad m => Task m a b c -> SF m a (Event d) -> Task m a b (Either c d) infixl 0

Run a "guarding" event source (SF m a (Event b)) in parallel with a (possibly non-terminating) task.

The task will be aborted at the first occurrence of the event source (if it has not terminated itself before that).

Useful for separating sequencing and termination concerns. E.g. we can do something "useful", but in parallel watch for a (exceptional) condition which should terminate that activity, without having to check for that condition explicitly during each and every phase of the activity.

Example: tsk abortWhen lbp