Index of values


(>>&) [Fut.Op]
f >>& fn is sbind f fn.
(>>&) [Fut]
f >>& fn is sbind f fn.
(>>=) [Fut.Op]
f >>= fn is bind f fn.
(>>=) [Fut]
f >>= fn is bind f fn.
(>>|) [Fut.Op]
f >>| fn is map fn f.
(>>|) [Fut]
f >>| fn is map fn f.

A
abort [Fut]
abort f aborts the future f.
accept [Futu]
accept fd is like Unix.accept fd except it handles EINTR and EWOULDBLOCK and sets the resulting file descriptor to non-blocking mode with Unix.set_nonblock.
action [Fut.Runtime]
action a executes a () as soon as possible on the runtime system thread.
app [Fut]
app ff fv is a future that determines f v where f is determined by ff and v by fv.
apply [Futu]
apply queue f v applies f v on queue and catches Unix.Unix_error.
apply [Fut]
apply queue abort fn v is a future that determines the value fn v on queue (defaults to Fut.Queue.concurrent).
available [Fut.Sem]
available s is s's number of available tokens.
await [Fut]
await timeout f, is like Fut.state except if f is undetermined it waits until f is set or timeout seconds passed.

B
bind [Futu]
bind [Fut]
bind f fn is the future fn v where v is the value determined by f.

C
call [Futu]
call f v applies f v synchronously and catches Unix.Unix_error.
capacity [Fut.Sem]
capacity s is s's token capacity.
close [Futu]
close fd is like Unix.close fd, except it handles EINTR and sets any pending read or write on fd to never determine.
concurrent [Fut.Queue]
concurrent is a special future queue.
connect [Futu]
connect is like Unix.connect except it handles EINTR and EINPROGRESS.
create [Fut.Sem]
create capacity is a semaphore with a token capacity of capacity.
create [Fut.Queue]
queue ~label () is a new queue with the given label, if unspecified a label is automatically generated.

D
delay [Fut]
delay d is a value that determines diff = d - d' in d seconds where d' is the actual time the runtime system took to determine the timer.
dup2 [Futu]
dup2 fd1 fd2 is like Unix.dup2 fd1 fd2, except it handles EINTR and sets any pending read or write on fd2 to never determine.

E
error [Fut]

F
fd_action [Fut.Runtime]
fd_action fds fd a executes a true whenever fd is in the state fds.
fd_close [Fut.Runtime]
TODO
finally [Fut]
finally fn v f is f but fn v is called (and its result ignored) whenever f is set and immediately if f is already set at call time.
first [Fut]
first f f' is a future that determines (v, snd) where v is the value of the first future to determine and snd is the other one.
firstl [Fut]
next fs is a future that determines (v, fs') where v is the first value to determine in fs and fs' are the remaining ones.
fold [Fut]
fold fn acc [f1; ...; fn] is List.fold_left fn acc [v1; ...; vn] where vi is the value determined by the future fi.
future [Fut]
future p is the future set by promise p.

I
ignore [Fut]
ignore f is Fut.map (fun _ -> ()) f.

L
label [Fut.Queue]
queue_label q is q's label.

M
map [Fut]
map fn f is a future that determines the value fn v where v is the value determined by f.

N
name [Fut.Runtime]
name is the backend name.
never [Fut]
never () is a future that never determines a value.
nonblock_stdio [Futu]
nonblock_stdio () sets Unix.stdin, Unix.stdout, Unix.stderr to non-blocking mode.

O
of_event [Futr]
of_event e is a future that determines on the next occurence of e.
ok [Fut]

P
pick [Fut]
pick f f' is a future that determines as the first future that does and sets the other to never determine.
pickl [Fut]
pickl fs is List.fold_left Fut.pick (Fut.never ()) fs.
pipe [Futu]
pipe () is like Unix.pipe (), except is sets both file descriptors to non-blocking mode with Unix.set_nonblock.
pp_exn_info [Fut.Runtime]
pp_exn_info ppf i prints an unspecified representation of i on ppf.
promise [Fut]
promise abort () is a new promise.
protect [Fut]
protect f is a future that behaves like f but is insensitive to Fut.abort.

R
read [Futu]
read fd s j l is like Unix.read fd s j l except it handles EINTR, EAGAIN and EWOULDBLOCK.
recover [Fut]
recover f is a future that determines `Det v if f determined v or `Never if f was set to never determine.
ret [Fut]
ret v is a future that determines the value v immediately.
return [Fut.Sem]
return s token returns the token token to s.

S
sbind [Fut]
set [Fut]
set p s sets Fut.future p to s.
set_exn_trap [Fut.Runtime]
set_exn_trap h is a function called whenever the runtime system traps an exception.
set_worker_count [Fut.Runtime]
set_worker_count n sets the number of workers to n.
signal [Futu]
signal s determines with s the next time the signal s is received by the program.
signal_action [Fut.Runtime]
signal_action s def calls def with an abort function to get (action,v).
socket [Futu]
socket d t p is like Unix.socket d t p except it sets the resulting file descriptor to non-blocking mode with Unix.set_nonblock.
socketpair [Futu]
socketpair d t p is like Unix.socketpair d t p except it sets the resulting file descriptors to non-blocking mode with Unix.set_nonblock.
state [Fut]
state f is the current state of f.
state_set [Fut]
state_set f is the set state of f.
sustain [Fut]
sustain f f' determines like f if it does and like f' if f never determines.
sync [Fut]
sync f is like Fut.await but blocks until f is set.

T
take [Fut.Sem]
take s is a future that determines as follows: If at call time available s > 0, decrements available s and determines a token immediately., Otherwise determines when available s becomes > 0 and all previous futures resulting from take s have been set (i.e. you are served in FIFO order).
tick [Fut]
tick d is Fut.ignore (Fut.delay d).
timer_action [Fut.Runtime]
timer_action d def calls def with an abort function to get (action,v).
to_event [Futr]
to_event f occurs once when f () determines.

W
worker_count [Fut.Runtime]
worker_count () is the number of workers used by the backend.
write [Futu]
write fd s j l is like Unix.single_write fd s j l except it handles EINTR, EAGAIN and EWOULDBLOCK.