(=<<) [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 | |
ba_write [Duppy.Transport_t] | |
bind [Duppy.Monad] |
Compose two computations.
|
broadcast [Duppy.Monad.Condition.Factory] | 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.Factory] |
Create a condition.
|
create [Duppy.Monad.Mutex.Mutex_t] | create () creates a mutex.
|
create [Duppy] |
Initiate a new scheduler
|
D | |
delay [Duppy.Monad.Monad_io_t] | delay ~priority h d creates a computation that returns
unit after delay d in seconds.
|
E | |
exec [Duppy.Monad.Monad_io_t] | 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.Mutex_t] |
A computation that locks a mutex
and returns
unit afterwards.
|
P | |
priority [Duppy.Monad.Mutex.Mutex_control] | |
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.Transport_t] | |
read [Duppy.Monad.Monad_io_t] | 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_t] |
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.Monad_io_t] | 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 | |
scheduler [Duppy.Monad.Mutex.Mutex_control] | |
signal [Duppy.Monad.Condition.Factory] | signal c is a computation that resumes one
computation waiting on c .
|
sock [Duppy.Transport_t] | |
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.Mutex_t] |
A computation that tries to lock a mutex.
|
U | |
unlock [Duppy.Monad.Mutex.Mutex_t] |
A computation that unlocks a mutex.
|
W | |
wait [Duppy.Monad.Condition.Factory] | 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.Transport_t] | |
write [Duppy.Monad.Monad_io_t] | write ?timeout ~priority h s creates a computation
that writes string s to h.socket .
|
write [Duppy.Io_t] |
Similar to
read but less complex.
|
write_bigarray [Duppy.Monad.Monad_io_t] | write_bigarray ?timeout ~priority h ba creates a computation
that writes data from ba to h.socket .
|