|
| (=<<) [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] |
|
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 [Duppy.Monad.Mutex.Mutex_t] |
create () creates a mutex.
|
| create [Duppy] |
|
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.
|