Transient.Base

See http://github.com/agocorona/transient everithing in this module is exported in order to allow extensibility.

Documentation

(!>) :: a -> b -> a infixr 0

(!!>) :: c -> String -> c infixr 0

data TransIO x

Constructors

Transient

Fields

runTrans :: StateT EventF IO (Maybe x)

Instances

Monad TransientIO

Functor TransientIO

Applicative TransientIO

Alternative TransientIO

MonadPlus TransientIO

MonadIO TransientIO

MonadState EventF TransientIO

Monoid a => Monoid (TransientIO a)

type SData = ()

type EventId = Int

type TransientIO = TransIO

data EventF

Constructors

forall a b . EventF

Fields

event :: Maybe SData

xcomp :: TransientIO a

fcomp :: [b -> TransientIO b]

mfData :: Map TypeRep SData

mfSequence :: Int

threadId :: ThreadId

freeTh :: Bool

parent :: Maybe EventF

children :: TVar [EventF]

maxThread :: Maybe (P Int)

Instances

MonadState EventF TransientIO

type P = IORef

newp :: a -> IO (IORef a)

(=:) :: MonadIO m => IORef a -> (a -> a) -> m ()

addr :: a -> String

type StateIO = StateT EventF IO

runTransient :: TransientIO x -> IO (Maybe x, EventF)

getCont :: MonadState EventF m => m EventF

get the continuation context: closure, continuation, state, child threads etc

runCont :: EventF -> StateIO ()

run the continuation context

compose :: (Monad f, Alternative f) => [a1 -> f a1] -> a1 -> f a

compose a list of continuations

runClosure :: EventF -> StateIO (Maybe a)

run the closure (the x in 'x >>= f') of the current bind operation.

runContinuation :: EventF -> a -> StateIO (Maybe b)

run the continuation (the f in 'x >> f') of the current bind operation

runContinuations :: [a -> TransIO b] -> c -> TransIO d

run a chain of continuations. It is up to the programmer to assure by construction that each continuation type-check with the next and the parameter type match the input of the first continuation and that the output is of the type intended.

data IDynamic

dynamic serializable data for logging

Constructors

IDyns String

forall a . (Read a, Show a, Typeable a) => IDynamic a

Instances

Read IDynamic

Show IDynamic

type Recover = Bool

type CurrentPointer = [LogElem]

type LogEntries = [LogElem]

data LogElem

Constructors

WaitRemote

Exec

Step IDynamic

Instances

Read LogElem

Show LogElem

data Log

Constructors

Log Recover CurrentPointer LogEntries

data RemoteStatus

Constructors

WasRemote

NoRemote

Instances

Eq RemoteStatus

stop :: TransientIO a

a sinonym of empty that can be used in a monadic expression. it stop the computation

setEventCont :: TransientIO a -> (a -> TransientIO b) -> StateIO ()

set the current closure and continuation for the current statement

resetEventCont :: Maybe a -> StateIO ()

reset the closure and continuation. remove inner binds than the prevous computations may have stacked in the list of continuations.

Threads

waitQSemB :: (Num a, Ord a) => IORef a -> IO Bool

signalQSemB :: Num a => IORef a -> IO ()

threads :: Int -> TransientIO a -> TransientIO a

set the maximun number of threads for a procedure. It is useful to limit the parallelization of transient code that uses parallel spawn and waitEvents

oneThread :: TransientIO a -> TransientIO a

delete all the previous childs generated by the expressions and continue execution of the current thread.

addThreads' :: Int -> TransIO ()

add n threads to the limit of threads. If there is no limit, it set it

addThreads :: (MonadIO m, MonadState EventF m) => Int -> m ()

assure that at least there are n threads left

getNonUsedThreads :: TransIO (Maybe Int)

freeThreads :: TransientIO a -> TransientIO a

The threads generated in the process passed as parameter will not be killed.

hookedThreads :: TransientIO a -> TransientIO a

The threads will be killed when the parent thread dies. That is the default. This can be invoked to revert the effect of freeThreads

killChilds :: TransientIO ()

kill all the child processes

extensible state: session data management

getSessionData :: (MonadState EventF m, Typeable a) => m (Maybe a)

Get the session data for the desired type if there is any.

getSData :: Typeable a => TransIO a

getSessionData specialized for the Transient monad. if Nothing, the monadic computation does not continue.

If there is no such data, getSData silently stop the computation. That may or may not be the desired behaviour. To make sure that this does not get unnoticed, use this construction:

 getSData <|> error "no data"

setSessionData :: (MonadState EventF m, Typeable a) => a -> m ()

set session data for this type. retrieved with getSessionData orr getSData

setSData :: (MonadState EventF m, Typeable a) => a -> m ()

a shorter name for setSessionData

delSessionData :: (Typeable * a, MonadState EventF m) => a -> m ()

delSData :: (MonadState EventF m, Typeable a) => a -> m ()

genNewId :: MonadIO m => MonadState EventF m => m Int

generator of identifiers

refSequence :: IORef Int

data StreamData a

async calls

Constructors

SMore a

SLast a

SDone

SError String

Instances

Read a => Read (StreamData a)

Show a => Show (StreamData a)

waitEvents :: IO b -> TransientIO b

variant of parallel that repeatedly executes the IO computation and kill the previously created childs

It is useful in single threaded problems where each event discard the computations spawned by previous events

waitEvents' :: IO b -> TransientIO b

async :: IO b -> TransientIO b

variant of + parallel` that execute the IO computation once, and kill the previous child threads

spawn :: IO b -> TransientIO b

variant that spawn free threads. Since there is not thread control, this is faster

parallel :: IO (StreamData b) -> TransientIO (StreamData b)

return empty to the current thread and launch the IO action in a new thread and attaches the continuation after it. if the result of the action is Right the process is repeated. if not, it finish.

If the maximum number of threads, set with threads has been reached parallel perform the work sequentially, in the current thread.

When parallelfinish, increase the counter of threads available, if there is a limitation of them.

The behaviour of parallel depend on StreamData if SMore, parallel will excute again the IO action. with SLast, SDone and SError, parallel will execute the continuation and will stop.

loop :: EventF -> IO (StreamData t) -> IO ()

forkFinally1 :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId

free :: ThreadId -> EventF -> IO (Maybe EventF)

addThread :: EventF -> EventF -> IO ()

killChildren :: EventF -> IO ()

kill all the threads associated with the continuation context

type EventSetter eventdata response = (eventdata -> IO response) -> IO ()

type ToReturn response = IO response

react :: Typeable eventdata => EventSetter eventdata response -> ToReturn response -> TransientIO eventdata

deinvert an event handler. The first parameter is the event handler to be deinverted the second is the value to return to the event handler it configures the event handler by calling the first parameter, that set the event handler, with the current continuation

non-blocking keyboard input

getLineRef :: TVar (Maybe a)

roption :: MVar [t]

option :: (Typeable b, Show b, Read b, Eq b) => b -> [Char] -> TransientIO b

install a event receiver that wait for a string and trigger the continuation when this string arrives.

input :: (Typeable a, Read a) => (a -> Bool) -> TransientIO a

validates an input entered in the keyboard in non blocking mode. non blocking means that the user can enter also anything else to activate other option unlike option, input only wait for one valid response

getLine' :: (Read a, Typeable * a) => (a -> Bool) -> IO a

non blocking getLine with a validator

reads1 :: (Read a, Typeable * a) => String -> [(a, String)]

inputLoop :: IO b

processLine :: String -> IO ()

rexit :: MVar a

stay :: IO a

keep :: TransIO a -> IO a

keep the main thread running, initiate the asynchronous keyboard input and execute the transient computation. It also read a slash separated list of string that are interpreted by option and input as if they were entered by the keyboard

keep' :: TransIO a -> IO a

same than keepbut do not initiate the asynchronous keyboard input. Useful for debugging

exit :: TransientIO a

force the finalization of the main thread and thus, all the application

onNothing :: Monad m => m (Maybe b) -> m b -> m b

alternative operator for maybe values. Used in infix mode