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
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.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.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.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
scheduler [Duppy.Monad.Mutex.Mutex_control]
signal [Duppy.Monad.Condition.Factory]
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.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.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.