| (=<<) [Duppy.Monad] | =<< is an alternative notation for catch.
|
| (>>=) [Duppy.Monad] | >>= is an alternative notation
for bind
|
A | |
| add [Duppy.Async] | add ~priority s f creates an asynchronous task in s with
priority priority.
|
| add [Duppy.Task] |
Schedule a task.
|
B | |
| bind [Duppy.Monad] |
Compose two computations.
|
| broadcast [Duppy.Monad.Condition] | broadcast c is a computation that
resumes all computations waiting on c.
|
C | |
| catch [Duppy.Monad] | catch f g redirects values x raised during
f's execution to g.
|
| create [Duppy.Monad.Condition] |
Create a condition.
|
| create [Duppy.Monad.Mutex] | create ~priority s creates a mutex.
|
| create [Duppy] |
Initiate a new scheduler
|
D | |
| delay [Duppy.Monad.Io] | delay ~priority h d creates a computation that returns
unit after delay d in seconds.
|
E | |
| exec [Duppy.Monad.Io] | exec ?delay ~priority h f redirects computation
f into a new queue with priority priority and
delay delay (0. by default).
|
F | |
| fold_left [Duppy.Monad] | fold_left f a [b1; b2; ..] returns computation
(f a b1) >>= (fun a -> f a b2) >>= ...
|
I | |
| iter [Duppy.Monad] | iter f [x1; x2; ..] returns computation
f x1 >>= (fun () -> f x2) >>= ...
|
L | |
| lock [Duppy.Monad.Mutex] |
A computation that locks a mutex
and returns
unit afterwards.
|
Q | |
| queue [Duppy] | queue ~log ~priorities s name
starts a queue, on the scheduler s only processing priorities p
for which priorities p returns true.
|
R | |
| raise [Duppy.Monad] | raise x create a computation that raises
value x.
|
| read [Duppy.Monad.Io] | read ?timeout ~priority ~marker h creates a
computation that reads from h.socket
and returns the first string split
according to marker.
|
| read [Duppy.Io] |
Wrapper to perform a read on a socket and trigger a function when
a marker has been detected, or enough data has been read.
|
| read_all [Duppy.Monad.Io] | read_all ?timeout ~priority s sock creates a
computation that reads all data from sock
and returns it.
|
| return [Duppy.Monad] | return x create a computation that
returns value x.
|
| run [Duppy.Monad] | run f ~return ~raise () executes f and process
returned values with return or raised values
with raise.
|
S | |
| signal [Duppy.Monad.Condition] | signal c is a computation that resumes one
computation waiting on c.
|
| stop [Duppy.Async] |
Stop and remove the asynchronous task.
|
| stop [Duppy] |
Stop all queues running on that scheduler, causing them to return.
|
T | |
| try_lock [Duppy.Monad.Mutex] |
A computation that tries to lock a mutex.
|
U | |
| unlock [Duppy.Monad.Mutex] |
A computation that unlocks a mutex.
|
W | |
| wait [Duppy.Monad.Condition] | wait h m is a computation that:
Unlock mutex m, Wait until Condition.signal c or Condition.broadcast c
has been called, Locks mutex m, Returns unit
|
| wake_up [Duppy.Async] |
Wake up an asynchronous task.
|
| write [Duppy.Monad.Io] | write ?timeout ~priority h s creates a computation
that writes string s to h.socket.
|
| write [Duppy.Io] |
Similar to
read but less complex.
|
| write_bigarray [Duppy.Monad.Io] | write_bigarray ?timeout ~priority h ba creates a computation
that writes data from ba to h.socket.
|