Orc.Combinators

Documentation

signal :: Orc ()

Alternate phrasing of return (), which can be placed at the end of an Orc computation to signal that it has no more values to produce.

cut :: Orc a -> Orc a

Cut executes an orc expression, waits for the first result, and then suppresses the rest, including killing any threads involved in computing the remainder.

onlyUntil :: Orc a -> Orc b -> Orc b

Executes the computation p and done. Once done returns its first result, kill both computations and returns that result. This discards the results of p.

butAfter :: Orc a -> (Float, Orc a) -> Orc a

Immediately executes the computation p, but if it hasn't returned a result in t seconds, execute the computation q and return whichever computations returns a result first (killing the other thread).

timeout :: Float -> a -> Orc a -> Orc a

Executes a computation p, but if it hasn't returned a result in n seconds return a instead (killing the p computation).

silent :: Orc a -> Orc b

Executes the computation p but suppresses its results.

liftList :: MonadPlus list => [a] -> list a

Lifts a list into an Orc monad.

repeating :: Orc a -> Orc a

Repeatedly executes the computation p and returns its results. repeating works best when p is single-valued: if p is multivalued Orc will spawn a repeating thread for every result returned, resulting in an exponential blow-up of threads (XXX: I don't think this was actually intended.)

runChan :: Chan a -> Orc a -> IO ()

Runs a computation p and writes its results to the channel ch.

sync :: (a -> b -> c) -> Orc a -> Orc b -> Orc c

Takes the first result of p, the first result of q, and applies them to f. The computations for p and q are run in parallel.

notBefore :: Orc a -> Float -> Orc a

Runs the computation p and returns its first result, but doesn't return before w seconds have elapsed.

syncList :: [Orc a] -> Orc [a]

Runs a list of Orc computations ps in parallel until they produce their first result, and returns a list of all these results.

delay :: (RealFrac a, Show a) => a -> Orc ()

Wait for a period of w seconds, then continue processing.

printOrc :: Show a => Orc a -> IO ()

Runs an Orc computation, eagerly printing out the results of an Orc computation line-by-line.

prompt :: String -> Orc String

Prompts the user for a string. Concurrency-safe.

putStrLine :: String -> Orc ()

Writes a string and newline to standard output. Concurrency-safe.

scan :: (a -> s -> s) -> s -> Orc a -> Orc s

Analogous to the list scan function, but the order in which the combining function is applied to the results produced by p is nondeterministic.

(<?>) :: Orc a -> Orc a -> Orc a

A variant of <+>, pronounced or-else, which performs and returns the results of p, and if p produced no answers go on and performa dn return the results of q.

count :: Orc a -> Orc (Either a Int)

For each value produced by p, return a Left a. Once p has finished, return a Right Int containing the number of results produced.

collect :: Orc a -> Orc [a]

Collects all of the values of the computation p and delivers them as a list when p is completed.

takeOrc :: Int -> Orc a -> Orc a

List-like functions

Runs the computation p and returns the first n results.

dropOrc :: Int -> Orc a -> Orc a

Drops the first n results of the computation p, and then returns the rest of the results.

zipOrc :: Orc a -> Orc b -> Orc (a, b)

Zips the results of two computations p and q. When one computation finishes, kill the other.

sandbox :: Orc a -> MVar (Maybe a) -> MVar () -> Orc ()

Runs the computation p, and repeatedly puts its results (tagged with Just into the vals MVar. Puts Nothing if there are no results left. Stops executing when the end MVar is filled.

echo :: Int -> MVar (Maybe a) -> MVar () -> Orc a

The rough inverse of sandbox, repeatedly reads values from the vals MVar until j values have been read or the vals MVar is exhausted (a Nothing is passed). When there are no more values to be returned, fills the end MVar.

zipp :: MVar (Maybe a) -> MVar (Maybe b) -> MVar () -> Orc (a, b)

Like echo, repeatedly reads values from the pvals and qvals MVar, returning tuples of the values until one MVar is exhausted. When there are no more values to be returned, fills the end MVar.

publish :: NFData a => a -> Orc a

Publish is a hyperstrict form of return. It is useful for combining results from multiple val computations, providing a synchronization point.