Control.Concurrent.STM.Promise.Tree

A tree of computation

Trees

data Tree a

Both/Either-trees

Constructors

Node Label (Tree a) (Tree a)

Combine two trees with the semantics of Label

Leaf a

A computation

Recoverable (Tree a)

There is a mean of recovering this computation, by returning mempty

Instances

Monad Tree

Functor Tree

Applicative Tree

Foldable Tree

Traversable Tree

Eq a => Eq (Tree a)

Ord a => Ord (Tree a)

Show a => Show (Tree a)

Typeable (* -> *) Tree

data Label

Both/Either labels

Constructors

Both

Both of these must succeed with an An

Either

Either of these must succeed with an An, and that one is returned

Instances

Eq Label

Ord Label

Show Label

Typeable * Label

Creating trees

requireAll :: [Tree a] -> Tree a

All of these must succeed

requireAny :: [Tree a] -> Tree a

Any of these must succeed

tryAll :: [Tree a] -> Tree a

As many as possible should succeed, try all.

Evaluating trees

evalTree :: forall a. Monoid a => (a -> Bool) -> Tree (Promise a) -> IO (a, a)

Evaluates a tree of promises, cutting of unnecessary branches, given that some other thread(s) evaluates the promises.

The first result is the failures, then the actual result comes

watchTree :: Monoid a => (a -> Bool) -> Tree (Promise a) -> IO (TChan a, DTVar (Tree (PromiseResult a)))

Assuming some other thread(s) evaluate the promises in the tree, this gives a live view of the progress, and cancels unnecessary subtrees (due to Either).

The first argument is a way to deem promises with results as failures. `(== mempty)` or (const False) could be good alternatives. These failures are sent to the TChan.

Scheduling

interleave :: Tree a -> [a]

A simple scheduling (see workers)

interleave' :: Tree a -> [a]

A somewhat smarter scheduling (see workers)

Utilities

showTree :: Show a => Tree a -> String

Shows a tree