Index of values


(=<<) [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`.