Index of values


(%%) [B0_std.Cmd]
l1 % l2 is append l1 l2.
(%) [B0_std.Cmd]
l % a is append l (arg a).
(+) [B0_std.Fpath]
p + ext is add_ext p ext.
(-+) [B0_std.Fpath]
p -+ ext is set_ext p ext.
(/) [B0_std.Fpath]
p / seg is add_seg p seg.
(//) [B0_std.Fpath]
p // p' is append p p'.

A
a [B0_web.Htmlg.El]
a
abbr [B0_web.Htmlg.El]
abs_diff [B0_std.Time.Span]
abs_diff s0 s1 is the absolute difference between s0 and s1.
add [B0_vcs.Git]
add t ~force fs adds fs to r's staged changes.
add [B00.Guard]
add g o guards o in g until it is allowed.
add [B00.Op_cache]
add c o adds operation o to the cache.
add [B00.File_cache]
add c k m fs, binds the metadata m and the contents of the ordered list of files fs to k in c.
add [B0_std.Time.Span]
add s0 s1 is s0 + s1.
add_ext [B0_std.Fpath]
add_ext ext p is p with ext concatenated to p's basename.
add_fun [B0_std.Hash]
add_fun m adds m to the list returned by funs.
add_if [B0_web.Htmlg.Att]
add_if c att atts is att :: atts if c is true and atts otherwise.
add_seg [B0_std.Fpath]
add_seg p seg if p's last segment is non-empty this is p with seg added.
add_some [B0_web.Htmlg.Att]
add_some n o atts is (v n value) :: atts if o is Some value and atts otherwise.
address [B0_web.Htmlg.El]
all_keys [B00.File_cache.Stats]
all_keys s are statistics about all keys in the cache.
allowed [B00.Guard]
allowed g is an operation that is either ready or aborted in g (if any).
app [B0_std.Log]
app is msg App.
append [B0_std.Cmd]
append l1 l2 appends arguments l2 to l1.
append [B0_std.Fpath]
append p q appends q to p as follows: q is absolute or has a non-empty volume then q is returned., Otherwise appends q's segment to p using B0_std.Fpath.add_seg.
apply [B0_std.Os.Fd]
apply ~close fd f calls f fd and ensure close fd is is called whenever the function returns.
area [B0_web.Htmlg.El]
arg [B0_std.Cmd]
arg a is the argument a.
args [B00.Op.Spawn]
args s are the spawned tool arguments.
args [B0_std.Cmd]
args ?slip l is a command line from the list of arguments l.
args0 [B00.Tool]
args0 is response file support for tools that reads null byte (0x00) terminated arguments response files via an -args0 FILE command line synopsis.
arr [B0_web.Jsong]
arr is an empty array.
arr_end [B0_web.Jsong]
arr_end els is arr a a generated JSON value.
array [B0_web.Jsonq]
array q queries the elements of a JSON array with q.
array [B0_std.Conv]
array c is like B0_std.Conv.list but converts arrays.
array [B0_std.Fmt]
array ~sep pp_v formats array elements.
article [B0_web.Htmlg.El]
aside [B0_web.Htmlg.El]
assets_url [B0_github.Release]
assets_url t is the issue's assets url.
atom [B0_std.Conv]
atom converts strings assumed to represent UTF-8 encoded Unicode text; but the encoding is not checked.
atom_non_empty [B0_std.Conv]
atom_non_empty is like B0_std.Conv.atom but ensures the atom is not empty.
audio [B0_web.Htmlg.El]
auth [B0_github]
auth ~http ~user () determines a personal access token for user user.
autofocus [B0_web.Htmlg.Att]

B
b [B0_web.Htmlg.El]
b
background [B0_ui.Browser]
background is a --background option to use the background argument of !show.
base [B0_web.Htmlg.El]
basename [B0_std.Fpath]
basename p is the last non-empty segment of p or the empty string otherwise.
bdi [B0_web.Htmlg.El]
bdo [B0_web.Htmlg.El]
bin_dec [B0_std.Conv]
bin_dec c is the binary decoder of c.
bin_enc [B0_std.Conv]
bin_enc c is the binary encoder of c.
bind [B0_std.Result]
bind r f is Ok (f v) if r is Ok v and r if r is Error _.
bind [B0_std.Option]
bind o f is Some (f v) if o is Some v and None if o is None.
blockquote [B0_web.Htmlg.El]
body [B0_web.Htmlg.El]
body [B0_github.Release]
body r is the description of the release.
body [B0_github.Issue]
body t is the issue's body.
bool [B0_web.Jsonq]
bool queries a boolean JSON value.
bool [B0_web.Jsong]
bool b is b as a generated JSON boolean value.
bool [B0_std.Conv]
bool converts booleans.
bool [B0_std.Fmt]
bool is Format.pp_print_bool.
box [B0_std.Fmt]
box ~indent pp ppf wraps pp in a horizontal or vertical box.
br [B0_web.Htmlg.El]
br
braces [B0_std.Fmt]
braces pp_v ppf is pf ppf "@[<1>{%a}@]" pp_v.
brackets [B0_std.Fmt]
brackets pp_v ppf is pf ppf "@[<1>[%a]@]" pp_v.
branch_delete [B0_vcs.Git]
branch_delete r ~force ~branch deletes branch in r.
break_left [B0_std.String]
break_left n v is (take_left n v, drop_left n v).
break_right [B0_std.String]
break_right n v is (drop_left n v, take_right n v).
browser [B0_ui.Browser]
browser is a --browser option and BROWSER environment variable to use with the browser argument of B0_ui.Browser.find.
buffer_add [B0_web.Jsong]
buffer_add b g adds the generated JSON value g to b.
buffer_add [B0_web.Htmlg.El]
buffer_add ~doc_type b c adds child c (or children if c is a B0_web.Htmlg.El.splice) to b.
button [B0_web.Htmlg.El]
by_name [B00.Tool]
by_name is like B00.Tool.v but reference the tool directly via a name.
byte [B0_std.Conv]
byte converts a byte.
byte_size [B0_std.Fmt]
byte_size is si_size ~scale:0 "B".

C
cache [B0_std.Os.Dir]
cache () is the directory used to store user-specific non-essential data.
canvas [B0_web.Htmlg.El]
cap [B0_std.Tty]
cap tty determines tty's capabilities.
capitalize [B0_std.String.Ascii]
capitalize s is like B0_std.String.Ascii.uppercase but performs the map only on s.[0].
caption [B0_web.Htmlg.El]
catch_failure [B0_std.Result]
catch_failure f is try Ok (f ()) with Failure e -> Error e
catch_sys_error [B0_std.Result]
catch_sys_error f is try Ok (f ()) with Sys_error e -> Error e
changes [B0_vcs]
changes r ~after ~until is the list of commits with their one-line synopsis from commit-ish after to commit-ish until.
char [B0_std.Fmt]
char is Format.pp_print_char.
charset [B0_web.Htmlg.Att]
check_kind [B0_vcs.Git]
check_kind r is Ok () if r's kind is Git and errors otherwise.
checked [B0_web.Htmlg.Att]
checkout [B0_vcs]
checkout r ~and_branch commit_ish checks out commit_ish in the working directory of r.
cite [B0_web.Htmlg.El]
class' [B0_web.Htmlg.Att]
clock [B00.Memo]
clock m is m's clock.
clone [B0_vcs]
clone r ~dir clones r to a working directory dir and returns a repo to operate on it.
close [B0_github.Issue]
close auth repo n closes issues n on the repository repo
cmd [B0_web.Jsong]
cmd c is c as a generated JSON string array value.
cmd [B0_vcs]
cmd r is the base command to use to act on r.
cmd [B0_ui.B0_std.Arg]
cmd is a converter for commands.
code [B0_web.Htmlg.El]
col [B0_web.Htmlg.El]
colgroup [B0_web.Htmlg.El]
collect [B00.Exec]
collect e ~block removes from e an operation that has completed (if any).
color [B0_ui.B0_std]
color ~docs ~env is a cli interface for specifiying the color capability of the terminal.
comma [B0_std.Fmt]
comma is unit ",@ ".
command [B0_web.Htmlg.El]
commit [B0_vcs.Git]
commit r ~sign ~msg ~ammend ~reset_author is basically git commit, see git-commit(1) for the semantics of options.
commit_files [B0_vcs]
commit_files r ~msg files commits the file files with message msg (if unspecified the VCS should prompt).
commit_id [B0_vcs]
commit_id r ~dirty_mark ~commit_ish is the object name (identifier) of commit_ish.
commit_ptime_s [B0_vcs]
commit_ptime_s t commit_ish is the POSIX time in seconds of commit commit_ish of repository r.
compare [B00.Op]
compare o0 o1 is Pervasives.compare (id o0) (id o1).
compare [B0_std.Time.Span]
compare s0 s1 orders span by increasing duration.
compare [B0_std.Hash]
compare h0 h1 is a total order on hashes compatible with B0_std.Hash.equal.
compare [B0_std.Fpath]
compare p0 p1 is a total order on paths compatible with B0_std.Fpath.equal.
compare [B0_std.Result]
compare ~ok ~error r0 r1 totally orders r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _.
compare [B0_std.Option]
compare cmp o0 o1 is a total order on options using cmp to compare values wrapped by Some _.
config [B0_std.Os.Dir]
config () is the directory used to store user-specific program configurations.
content [B0_web.Htmlg.Att]
conv [B0_std.Cmd]
conv converts command lines.
conv [B0_std.Time.Span]
conv is a converter for timespans.
conv [B0_std.Hash]
conv converts using B0_std.Conv.string_bytes.
conv [B0_std.Fpath]
conv converts file paths.
conv_only [B0_std.Fpath]
conv_only converts file paths.
copy [B0_std.Os.Fd]
copy ~buf ~src dst reads src and writes it to dst using buf as a buffer; if unspecified a buffer of length B0_std.Os.Fd.unix_buffer_size is created for the call.
copy [B0_std.Os.Dir]
copy ~rel ~atomic ~prune ~follow_symlinks ~make_path ~recurse ~src dst copies the directory src to dst.
copy [B0_std.Os.File]
copy ~atomic ~mode ~force ~path ~make_path ~src file operates like B0_std.Os.File.write_with_fd but directly writes the content of src (or stdin if src is B0_std.Os.File.dash) to file.
count [B0_std.Time]
count c is the monotonic time span elapsed since c was created.
counter [B0_std.Time]
counter () is a counter counting from now on.
cpu_children_stime [B0_std.Time]
cpu_utime_s cpu is cpu's system time in seconds for children processes.
cpu_children_utime [B0_std.Time]
cpu_utime_s cpu is cpu's user time in seconds for children processes.
cpu_clock [B00.Memo]
cpu_clock m is m's cpu clock.
cpu_count [B0_std.Time]
cpu_count c are CPU times since c was created.
cpu_counter [B0_std.Time]
cpu_counter () is a counter counting from now on.
cpu_span_conv [B0_std.Time]
cpu_span_conv is a converter for cpu spans.
cpu_stime [B0_std.Time]
cpu_stime_s cpu is cpu's system time in seconds.
cpu_utime [B0_std.Time]
cpu_utime_s cpu is cpu's user time in seconds.
cpu_zero [B0_std.Time]
cpu_zero is zero CPU times.
create [B0_github.Release]
create auth repo ~tag_name ~body () creates a new release in repository repo with given tag_name and body description.
create [B0_github.Issue]
create auth repo opens an issue on the repository repo with the given title and body.
create [B00.Memo.Fut]
create memo is (f, s) a future value f and a setter s for it.
create [B00.Memo]
create [B00.Exec]
create ~clock ~rand ~tmp_dir ~notify_submit ~max_spawn with: max_spawn the maximal number of processes spawn simultaneously., feedback called with each scheduled operation when it gets submitted for execution. Default is a nop., tmp_dir is a directory for temporary files, it must exist; defaults to B0_std.Os.Dir.default_tmp ()., rand random state used for internal queues; defaults to Random.State.make_self_init., clock, the clock used to timestamp the operations; defaults to B0_std.Time.counter ().
create [B00.Guard]
create ~feedback () is a new guard, using feedback to report inconsistencies (default is a nop.).
create [B00.Op_cache]
create ~clock ~hash_fun c is an operation cache with c the file cache used to memoize build operations, hash_fun the hash function used to hash files and build operations; defaults to B0_std.Hash.Xxh_64, clock the clock used to measure file hashing time and timestamp revived operations defaults to B0_std.Time.counter ().
create [B00.File_cache]
create ~feedback dir is a file cache using directory dir for data storage.
create [B0_std.Os.Dir]
create ~mode ~make_path dir creates the directory dir.
creation_time [B00.Op]
creation_time o is o's creation time.
curl [B0_web.Http]
curl is a cli interface for specifying the curl command line tool.
current [B0_std.Os.Env]
current () is the current process environment.
current_assignments [B0_std.Os.Env]
current_assignments () is the current process environment as assignments.
cut [B0_std.Fmt]
cut is Format.pp_print_cut.
cut_ext [B0_std.Fpath]
cut_ext ?multi p is (rem_ext ?multi p, get_ext ?multi p).
cut_left [B0_std.String]
cut ~sep s is either the pair Some (l,r) of the two (possibly empty) substrings of s that are delimited by the first match of the separator character sep or None if sep can't be matched in s.
cut_right [B0_std.String]
cut_right ~sep s is like B0_std.String.cut_left but matching starts on the right of s.
cuts_left [B0_std.String]
cuts_left sep s is the list of all substrings of s that are delimited by matches of the non empty separator string sep.
cuts_right [B0_std.String]
cuts_right sep s is like B0_std.String.cuts_left but matching starts on the right of s.
cwd [B00.Op.Spawn]
cwd s is the cwd with which s runs.
cwd [B0_std.Os.Dir]
cwd () is the current working directory.

D
dash [B0_std.Os.File]
dash is "-".
data [B00.Op.Write]
data w () is the data to write.
data [B0_std.Os.Dir]
data () is the directory used to store user-specific program data.
datalist [B0_web.Htmlg.El]
dd [B0_web.Htmlg.El]
dd
debug [B0_std.Log]
debug is msg Debug.
dec_atom [B0_std.Conv.Txt]
dec_atom ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comments, parses an atom and returns the index after it or the length of s.
dec_byte [B0_std.Conv.Bin]
dec_byte decodes an integer in range [0;255] for the given kind.
dec_bytes [B0_std.Conv.Bin]
dec_bytes ~kind decodes the given bytes for the given kind.
dec_err [B0_std.Conv.Txt]
dec_err ~kind i fmt raises a textual decoding error message for kind kind at input byte index i formatted according to fmt.
dec_err [B0_std.Conv.Bin]
dec_err ~kind i fmt raises a binary decoding error message for kind kind at input byte index i formatted according to fmt.
dec_err_atom [B0_std.Conv.Txt]
dec_err_atom ~kind i a exp raises a textual error message for kind kind at input byte index i and atom a indicating one of exp atoms was expected.
dec_err_eoi [B0_std.Conv.Txt]
dec_err_eoi ~kind i raises a textual error message for kind kind at input byte index i indicating an unexpected end of input.
dec_err_eoi [B0_std.Conv.Bin]
dec_err_eoi ~kind i raises a decoding error message for kind kind at input byte index i indicating an unexpected end of input.
dec_err_exceed [B0_std.Conv.Bin]
dec_err_exceed ~kind i v ~max raises a decoding error message for kind kind at input byte index i indicating v is not in the range 0;max.
dec_err_lexeme [B0_std.Conv.Txt]
dec_err_case ~kind i raises a textual error message for kind kind at input byte index i indicating one of exp was expected.
dec_le [B0_std.Conv.Txt]
dec_le ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comments, parses a list end and returns the index after it or the length of s.
dec_lexeme [B0_std.Conv.Txt]
dec_case ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comment, looks for either a left parenthesis, right parenthesis or an atom and returns the index of their first position.
dec_list [B0_std.Conv.Txt]
dec_list dec_v ~kind decodes a list of values decoded with dec_v for the given kind.
dec_list [B0_std.Conv.Bin]
bin_dec_list dec_v ~kind decodes a list of values decoded with dec_v for the given kind.
dec_list_tail [B0_std.Conv.Txt]
dec_list_tail dec_v ~kind ~lstart decodes list elements decoded with dec_v and an the end of list for the given kind, ls is the position of the list start.
dec_ls [B0_std.Conv.Txt]
dec_ls ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comments, parses a list start and returns the index after it or the length of s.
dec_need [B0_std.Conv.Bin]
dec_need ~kind s ~start ~len checks that len bytes are available starting at start (which can be out of bounds) in s and calls err_eoi if that is not the case.
dec_skip [B0_std.Conv.Txt]
dec_skip ~kind s ~start starting at start (which can be out of bounds) is the first non-white, non-comment, byte index or the length of s if there is no such index.
default_tmp [B0_std.Os.Dir]
default_tmp () is a default directory that can be used as a default directory for creating temporary files and directories.
del [B0_web.Htmlg.El]
delete [B0_std.Os.File]
delete file deletes file file from the file system.
delete [B0_std.Os.Path]
delete ~recurse p deletes p from the file system.
delete_tag [B0_vcs]
delete_tag r t deletes tag t in repo r.
delete_unused [B00.File_cache]
delete_unused c deletes unused keys of c.
describe [B0_vcs]
describe r dirty_mark commit_ish identifies commit_ish (defaults to "HEAD") using tags from the repository r.
details [B0_web.Htmlg.El]
dfn [B0_web.Htmlg.El]
did_not_write [B00.Op]
did_not_write o are the file of B00.Op.writes that do not exist or are not readable.
did_you_mean [B0_std.Fmt]
did_you_mean ~pre kind ~post pp_v formats a faulty value v and a list of hints that could have been mistaken for v.
dir [B00.Op.Mkdir]
dir mk is the directory created by mk.
dir [B00.File_cache]
dir c is c's storage directory.
dir_sep [B0_std.Fpath]
dir_sep is B0_std.Fpath.dir_sep_char as a string.
dir_sep_char [B0_std.Fpath]
dir_sep_char is the platform dependent natural directory separator.
disabled [B0_web.Htmlg.Att]
div [B0_web.Htmlg.El]
dl [B0_web.Htmlg.El]
dl
docvar [B0_std.Conv]
docvar c is the documentation meta-variable for values converted by c.
dom [B0_std.Fpath.Map]
dom m is the domain of m.
dom [B0_std.String.Map]
dom m is the domain of m.
don't [B0_ui.Pager]
don't ~docs () is a --no-pager command line option to unconditionally request not use a pager.
dquotes [B0_std.Fmt]
dquotes pp_v is pf "\"%a\"" pp_v
drop_left [B0_std.String]
drop_left n s is s without the first n bytes of s.
drop_right [B0_std.String]
drop_right n s is s without the last n bytes of s.
dt [B0_web.Htmlg.El]
dt
dump [B0_std.Cmd]
dump ppf l dumps and unspecified representation of l on ppf.
dump [B0_std.Fpath.Map]
dump pp_v ppf m prints an unspecified representation of m on ppf using pp_v to print the map codomain elements.
dump [B0_std.Fpath.Set]
dump ppf ss prints an unspecified representation of ss on ppf.
dump [B0_std.Fpath]
dump ppf p prints path p on ppf using B0_std.String.dump.
dump [B0_std.String.Map]
dump pp_v ppf m prints an unspecified representation of m on ppf using pp_v to print the map codomain elements.
dump [B0_std.String.Set]
dump ppf ss prints an unspecified representation of ss on ppf.
dump [B0_std.String]
dump ppf s prints s as a syntactically valid OCaml string on ppf.
dump_string_map [B0_std.String.Map]
dump_string_map ppf m prints an unspecified representation of the string map m on ppf.

E
edit_distance [B0_std.String]
edit_distance s0 s1 is the number of single character edits (insertion, deletion, substitution) that are needed to change s0 into s1.
edit_files [B0_ui.Editor]
edit-files editor fs uses editor to edit the files fs.
el [B0_web.Jsong]
el e arr is array arr wit e added at the end.
el_if [B0_web.Jsong]
el cond v arr is el (v ()) arr if cond is true and arr otherwise.
elided_string [B0_std.Fmt]
elieded_string ~max formats a string using at most max characters, eliding it if it is too long with three consecutive dots which do count towards max.
em [B0_web.Htmlg.El]
em
embed [B0_web.Htmlg.El]
empty [B0_std.Os.Env]
empty is String.Map.empty.
empty [B0_std.Cmd]
empty is an empty list of arguments.
empty [B0_std.String]
empty is "".
enc_atom [B0_std.Conv.Txt]
enc_atom ppf s encodes s as an atom on ppf quoting it as needed.
enc_byte [B0_std.Conv.Bin]
enc_byte encodes an integer in range [0;255].
enc_bytes [B0_std.Conv.Bin]
enc_bytes encodes the given bytes.
enc_err [B0_std.Conv.Txt]
enc_err ~kind fmt raises a textual encoding error message for kind kind formatted according to fmt.
enc_err [B0_std.Conv.Bin]
enc_err ~kind fmt raises a binary encoding error message for kind kind formatted according to fmt.
enc_list [B0_std.Conv.Txt]
enc_list enc_v encodes a list of values encoded with enc_v.
enc_list [B0_std.Conv.Bin]
enc_list enc_v encodes a list of values encoded with enc_v.
enum [B0_std.Conv]
enum ~kind ~docvar ~eq vs converts values present in vs.
env [B00.Memo]
env m is m's environment.
env [B00.Env]
env e is e's available spawn environment.
env [B00.Op.Spawn]
env s is the environment in which s runs.
env_tool_lookup [B00.Env]
env_tool_lookup ~sep ~var env is a tool lookup that gets the value of the var variable in env treats it as a sep separated search path and uses the result to lookup with B0_std.Os.Cmd.must_find.
envs [B0_ui.Editor]
envs describe the VISUAL and EDITOR environment variable.
envs [B0_ui.Pager]
envs describe the PAGER and TERM environment variable.
epr [B0_std.Fmt]
epr is Format.eprintf.
equal [B00.Op]
equal o0 o1 is id o0 = id o1.
equal [B0_std.Time.Span]
equal s0 s1 is s0 = s1.
equal [B0_std.Hash]
equal h0 h1 is true iff h0 and h1 are equal.
equal [B0_std.Fpath]
equal p0 p1 is true iff p0 and p1 are stringwise equal.
equal [B0_std.Result]
equal ~ok ~error r0 r1 tests equality of r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _.
equal [B0_std.Option]
equal eq o0 o1 is true iff o0 and o1 are both None or if they are Some v0 and Some v1 and eq v0 v1 is true.
equal_basename [B0_std.Fpath]
equal_basename p0 p1 is String.equal (basename p0) (basename p1).
err [B0_std.Log]
err is msg Error.
err_count [B0_std.Log]
err_count () is the number of messages logged with level Error.
error [B0_std.Result]
error e is Error e.
error [B0_std.Fmt]
error fmt ... is kstr (fun s -> Error s) fmt ...
escape [B0_std.String.Ascii]
escape s escapes bytes of s to a representation that uses only US-ASCII printable characters.
escaper [B0_std.String]
escaper char_len set_char is a byte escaper that given a byte c uses char_len c bytes in the escaped form and uses set_char b i c to set the escaped form for c in b at index i returning the next writable index (no bounds check need to be performed).
exec [B00.Memo]
exec m is m's executors.
exec_duration [B00.Op]
exec_duration is the difference between B00.Op.exec_end_time and B00.Op.exec_start_time.
exec_end_time [B00.Op]
exec_end_time o is o's execution end time.
exec_start_time [B00.Op]
exec_start_time o is o's execution start time.
execv [B0_std.Os.Cmd]
execv ~env ~cwd f argv executes file f as a new process in environment env with args as the Sys.argv of this process (in particular Sys.argv.(0) is the name of the program not the first argument to the program).
exists [B0_std.Os.Dir]
exists dir is Ok true if dir is a directory in the file system and Ok false otherwise.
exists [B0_std.Os.File]
exists file is Ok true if file is a regular file in the file system and Ok false otherwise.
exists [B0_std.Os.Path]
exists p is Ok true if p exists in the file system and Ok false otherwise.
exists [B0_std.String]
exists p s is true iff there exists an index i of s with p s.[i] = true.
exn [B0_std.Fmt]
exn formats an exception.
exn_backtrace [B0_std.Fmt]
exn_backtrace formats an exception backtrace.

F
fail [B00.Memo]
fail fmt ... fails the fiber with the given error message.
fail_error [B00.Memo]
fail_error fails the fiber with the given error.
failwith [B0_std.Fmt]
failwith fmt ... is kstr (fun s -> failwith s) fmt ...
failwith_notrace [B0_std.Fmt]
failwith_notrace is like nt but Failure is raised with raise_notrace.
fd [B0_std.Hash.T]
fd fd mmap(2)s and hashes the object pointed by fd.
field [B0_std.Fmt]
field ~style l pp_v pretty prints a named field with label l styled according to style (defaults to [`Fg `Yellow]), using pp_v to print the value.
fieldset [B0_web.Htmlg.El]
figcaption [B0_web.Htmlg.El]
figure [B0_web.Htmlg.El]
file [B00.Op.Write]
file w is the file written by w.
file [B00.Op.Read]
file r is the file read by r.
file [B0_std.Hash.T]
file f is the hash of file f.
file_hash_dur [B00.Op_cache]
file_hash_dur c is the time spent hashing files.
file_hashes [B00.Op_cache]
file_hashes c is a map of the files that were hashed.
file_is_dirty [B0_vcs]
file_is_dirty r f is Ok true iff f has uncommited changes.
file_ready [B00.Memo]
ready m p declares path p to be ready, that is exists and is up-to-date in b.
find [B0_vcs]
find ~dir () finds, using VCS functionality, a repository starting in directory dir (if unspecified this is the cwd).
find [B0_ui.Browser]
find ~search ~browser tries to find a browser in a rather complex and platform dependent way.
find [B0_ui.Editor]
find ?search ~don't finds a suitable editor.
find [B0_ui.Pager]
find ~search ~don't finds a suitable pager.
find [B00.File_cache]
find c k is Some (mf, fs) if k is bound in c with mf the file that holds the key metadata and fs the files that hold the file contents of the key in the order given on B00.File_cache.add.
find [B0_std.Os.Cmd]
find ~search cmd resolves cmd's tool as B0_std.Os.Cmd.find_tool does.
find [B0_std.Os.Env]
find ~empty_to_none name is the value of the environment variable name in the current process environment, if defined.
find_curl [B0_web.Http]
find_first [B0_std.Os.Cmd]
find_first ~search cmds resolves cmds's Cmd.toos as B0_std.Os.Cmd.find_first_tool does.
find_first_tool [B0_std.Os.Cmd]
find_first_tool is the first tool that can be found in the list with B0_std.Os.Cmd.find_tool.
find_tool [B0_std.Os.Cmd]
find_tool ~search tool is the file path, if any, to the program executable for the tool specification tool.
find_value [B0_std.Os.Env]
find_value parse ~empty_to_none name is Option.bind parse (find ~empty_to_none name), except the error message of parse is tweaked to mention name in case of error.
finish [B00.Memo]
finish m finishes the memoizer.
float [B0_web.Jsonq]
float queries a float JSON value.
float [B0_web.Jsong]
float f is f as a generated JSON number.
float [B0_std.Conv]
float converts floating point numbers.
float [B0_std.Fmt]
float is pf ppf "%g".
flush [B0_std.Fmt]
flush is Format.pp_print_flush.
fold [B00.File_cache]
fold c f acc folds f over the contents of each key of c starting with acc.
fold [B0_std.Os.Dir]
fold ~rel ~dotfiles ~follow_symlinks ~prune ~recurse f dir acc folds f over the contents of dir starting with acc.
fold [B0_std.Result]
fold ~ok ~error r is ok v if r is Ok v and error e if r is Error e.
fold [B0_std.Option]
fold ~none ~some o is none if o is None and some v if o is Some v.
fold_dirs [B0_std.Os.Dir]
fold_dirs is like B0_std.Os.Dir.fold but f is only applied to directory files.
fold_files [B0_std.Os.Dir]
fold_files is like B0_std.Os.Dir.fold but f is only applied to non-directory files.
footer [B0_web.Htmlg.El]
for' [B0_web.Htmlg.Att]
for_all [B0_std.String]
for_all p s is true iff for all indices i of s, p s.[i] = true.
forced_env [B00.Env]
forced_env e is e's forced spawn environment.
form [B0_web.Htmlg.El]
funs [B0_std.Hash]
funs () is the list of available hash functions.

G
get [B0_web.Jsonq]
get is the identity function
get [B0_vcs]
get is like B0_vcs.find but errors if no VCS was found.
get [B0_github.Release]
get auth repo ~tag_name () gets the release with given tag_name in repo tag_name.
get [B0_std.Option]
get o is v if o is Some v and
get_error [B0_std.Result]
get_error r is e if r is Error e and
get_ext [B0_std.Fpath]
get_ext p is p's basename file extension or the empty string if there is no extension.
get_mkdir [B00.Op]
get_mkdir o is the mkdir o.
get_mode [B0_std.Os.Path]
get_mode p is the file mode of p.
get_ok [B0_std.Result]
get_ok r is v if r is Ok v and
get_read [B00.Op]
get_read o is the read o.
get_spawn [B00.Op]
get_spawn o is the spawn o.
get_tool [B0_std.Cmd]
get_tool is like B0_std.Cmd.tool but
get_write [B00.Op]
get_write o is the write o.
guard [B00.Memo]
guard m is m's guard.
guarded_ops [B00.Guard]
guarded_opts g is the list of operations that are not ready in g.

H
h1 [B0_web.Htmlg.El]
h1
h2 [B0_web.Htmlg.El]
h2
h3 [B0_web.Htmlg.El]
h3
h4 [B0_web.Htmlg.El]
h4
h5 [B0_web.Htmlg.El]
h5
h6 [B0_web.Htmlg.El]
h6
has_ext [B0_std.Fpath]
has_ext ext p is true iff String.equal (get_ext p) e || String.equal (get_ext ~multi:true p) e.
hash [B00.Op]
hash o is the operation's hash.
hash_fun [B00.Op_cache]
hash_fun c is the hash function used by the operation cache.
hbox [B0_std.Fmt]
hbox is like B0_std.Fmt.box but is a horizontal box: the line is not split in this box (but may be in sub-boxes).
head [B0_web.Htmlg.El]
head [B0_vcs]
head is "HEAD".
head [B0_std.String]
head s if Some s.[0] if s <> "" and None otherwise.
header [B0_web.Htmlg.El]
height [B0_web.Htmlg.Att]
hex_digit_value [B0_std.Char.Ascii]
hex_digit_value c is the numerical value of a digit that satisfies B0_std.Char.Ascii.is_hex_digit.
hgroup [B0_web.Htmlg.El]
hr [B0_web.Htmlg.El]
hr
href [B0_web.Htmlg.Att]
html [B0_web.Htmlg.El]
html_url [B0_github.Release]
html_url t is the issue's HTML url.
hvbox [B0_std.Fmt]
hvbox is like B0_std.Fmt.box but is either B0_std.Fmt.hbox if its fits on a single line or B0_std.Fmt.vbox otherwise.

I
i [B0_web.Htmlg.El]
i
id [B0_web.Htmlg.Att]
id [B0_github.Release]
id r is the id of the release.
id [B00.Op]
id o is the identifier of operation o.
id [B0_std.Hash.T]
id is an US-ASCII string identifying the hash function.
if' [B0_std.Cmd]
if' cond l is l if cond is true and B0_std.Cmd.empty otherwise.
if_error [B0_std.Log]
if_error ~level ~use v r is: v, if r is Ok v, use and e is logged with level (defaults to Error), if r is Error e.
if_error_pp [B0_std.Log]
if_error_pp ~level pp ~use r is v, if r is Ok v., use and e is logged with level (defaults to Error) using pp, if r is Error e.
iframe [B0_web.Htmlg.El]
img [B0_web.Htmlg.El]
in_fd [B0_std.Os.Cmd]
in_fd ~close fd is a standard input that reads from file descriptor fd.
in_file [B0_std.Os.Cmd]
in_file f is a standard input that reads from file f.
in_null [B0_std.Os.Cmd]
in_null is in_file File.null.
in_stdin [B0_std.Os.Cmd]
in_stdin is in_fd ~close:false Unix.stdin, a standard input that reads from the current process standard input.
in_string [B0_std.Os.Cmd]
in_string s is a standard input that reads the string s.
info [B0_std.Log]
info is msg Info.
input [B0_web.Htmlg.El]
ins [B0_web.Htmlg.El]
int [B0_web.Jsonq]
int queries a float JSON value and truncates it.
int [B0_web.Jsong]
int i is i as a generated JSON number.
int [B0_std.Conv]
int converts signed OCaml integers.
int [B0_std.Fmt]
int is Format.pp_print_int.
int31 [B0_std.Conv]
int31 converts signed 31-bit integers.
int32 [B0_std.Conv]
int32 converts signed 32-bit integers.
int32 [B0_std.Fmt]
int32 is pf ppf "%ld".
int64 [B0_std.Conv]
int64 converts signed 64-bit integers.
int64 [B0_std.Fmt]
int64 is pf ppf "%Ld".
invalid_arg [B0_std.Fmt]
invalid_arg fmt ... is kstr (fun s -> invalid_arg s) fmt ...
is_abs [B0_std.Fpath]
is_abs p is true iff p is an absolute path, i.e.
is_alphanum [B0_std.Char.Ascii]
is_alphanum c is is_letter c || is_digit c.
is_blank [B0_std.Char.Ascii]
is_blank c is true iff c is an US-ASCII blank character, that is either space ' ' (0x20) or tab '\t' (0x09).
is_control [B0_std.Char.Ascii]
is_control c is true iff c is an US-ASCII control character, that is a byte in the range [0x00;0x1F] or 0x7F.
is_current_dir [B0_std.Fpath]
is_current_dir p is true iff p is either "." or "./".
is_digit [B0_std.Char.Ascii]
is_digit c is true iff c is an US-ASCII digit '0' ...
is_dir_path [B0_std.Fpath]
is_dir_path p is true iff p syntactically represents a directory.
is_dirty [B0_vcs]
is_dirty r is Ok true iff the working directory of r has uncommited changes.
is_empty [B0_std.Cmd]
is_empty l is true iff l is an empty list of arguments.
is_empty [B0_std.String]
is_empty s is equal empty s.
is_error [B0_std.Result]
is_error r is true iff r is Error _.
is_executable [B0_std.Os.File]
is_executable file is true iff file exists and is executable.
is_graphic [B0_std.Char.Ascii]
is_graphic c is true iff c is an US-ASCII graphic character that is a byte in the range [0x21;0x7E].
is_hex_digit [B0_std.Char.Ascii]
is_hex_digit c is true iff c is an US-ASCII hexadecimal digit '0' ...
is_infix [B0_std.String]
is_infix ~affix s is true iff there exists an index j such that for all indices i of affix, affix.[i] = s.[j+ 1].
is_letter [B0_std.Char.Ascii]
is_letter c is is_lower c || is_upper c.
is_lower [B0_std.Char.Ascii]
is_lower c is true iff c is an US-ASCII lowercase letter 'a' ...
is_nil [B0_std.Hash]
is_nil h is true iff h is B0_std.Hash.nil.
is_none [B0_std.Option]
is_none o is true iff o is None.
is_ok [B0_std.Result]
is_ok r is true iff r is Ok _.
is_parent_dir [B0_std.Fpath]
is_parent_dir p is true iff p is either ".." or "../".
is_prefix [B0_std.String]
is_prefix ~affix s is true iff affix.[i] = s.[i] for all indices i of affix.
is_print [B0_std.Char.Ascii]
is_print c is is_graphic c || c = ' '.
is_rel [B0_std.Fpath]
is_rel p is true iff p is a relative path, i.e.
is_rel_seg [B0_std.Fpath]
is_rel_seg s is true iff s is a relative segment in other words either "." or "..".
is_root [B0_std.Fpath]
is_root p is true iff p is a root directory, i.e.
is_seg [B0_std.Fpath]
is_seg s is true iff s does not contain a B0_std.Fpath.dir_sep or a null byte.
is_singleton [B0_std.Cmd]
is_singleton l is true iff l has a single argument.
is_some [B0_std.Option]
is_some o is true iff o is Some o.
is_suffix [B0_std.String]
is_suffix ~affix s is true iff affix.[i] = s.[m - i] for all indices i of affix and with m = String.length s - 1.
is_unused [B00.File_cache]
is_unused c k is true iff k is bound in c and its content is being unused.
is_upper [B0_std.Char.Ascii]
is_upper c is true iff c is an US-ASCII uppercase letter 'A' ...
is_valid [B0_std.String.Ascii]
is_valid s is true iff only for all indices i of s, s.[i] is an US-ASCII character, i.e.
is_valid [B0_std.Char.Ascii]
is_valid c is true iff c is an US-ASCII character, that is a byte in the range [0x00;0x7F].
is_white [B0_std.Char.Ascii]
is_white c is true iff c is an US-ASCII white space character, that is one of space ' ' (0x20), tab '\t' (0x09), newline '\n' (0x0A), vertical tab (0x0B), form feed (0x0C), carriage return '\r' (0x0D).
iter [B0_std.Result]
iter f r is f v if r is Ok v and () otherwise.
iter [B0_std.Option]
iter f o is f v if o is Some v and () otherwise.
iter [B0_std.Fmt]
iter ~sep iter pp_elt formats the iterations of iter over a value using pp_elt.
iter_bindings [B0_std.Fmt]
iter_bindings ~sep iter pp_binding formats the iterations of iter over a value using pp_binding.
iter_error [B0_std.Result]
iter_error f r is f e if r is Error e and () otherwise.

J
jobs [B0_ui.Memo]
jobs is a cli interface for specifying the maximal number of commands to spawn concurrently.
join [B0_std.Result]
join rr is r if rr is Ok r and rr if rr is Error _.
join [B0_std.Option]
join oo is Some v if oo is Some (Some v) and None otherwise.
json [B0_web.Jsonq]
json queries any JSON value.
json [B0_web.Jsong]
of_json v is the JSON value v as a generated value.

K
kbd [B0_web.Htmlg.El]
keep_left [B0_std.String]
keep_left sat s are the first consecutive sat statisfying bytes of s.
keep_right [B0_std.String]
keep_right sat s are the last consecutive sat satisfying bytes of s.
keygen [B0_web.Htmlg.El]
keys [B00.File_cache]
keys c are the keys of cache c.
keys_byte_size [B00.File_cache.Stats]
keys_count s is the total byte size of the files in the set of keys.
keys_count [B00.File_cache.Stats]
keys_count s is the number of keys in the set of keys.
keys_file_count [B00.File_cache.Stats]
keys_file_count s is the nubmer of files in the set of keys.
keys_sub [B00.File_cache.Stats]
keys_sub s0 s1 is he field-wise substraction s0 - s1.
keys_zero [B00.File_cache.Stats]
keys_zero are zeros.
kind [B0_vcs]
kind r is r's kind.
kind [B00.Op]
kind o is o's kind.
kind [B0_std.Conv]
kind c is the documented kind of value converted by c.
kind_name [B00.Op]
kind_name k is a end user name for kind k.
kmsg [B0_std.Log]
kmsg k level m logs m with level level and continues with k.
kmsg_default [B0_std.Log]
kmsg_default is the default logger that logs messages on B0_std.Fmt.stderr except for Log.App level which logs on B0_std.Fmt.stdout.
kmsg_nop [B0_std.Log]
nop_kmsg is a logger that does nothing.
kpf [B0_std.Fmt]
kpf is Format.kfprintf.
kstr [B0_std.Fmt]
kstr is Format.kasprintf.

L
label [B0_web.Htmlg.El]
legend [B0_web.Htmlg.El]
length [B0_std.Hash.T]
length is the byte length of hashes produced by the function.
length [B0_std.Hash]
length h is the length of h in bytes.
level [B0_std.Log]
level () is the current reporting level.
level_of_string [B0_std.Log]
level_of_string s parses a level from s according to the representation of B0_std.Log.level_to_string.
level_to_string [B0_std.Log]
level_to_string l converts l to a string representation.
li [B0_web.Htmlg.El]
li
lines [B0_std.Fmt]
lines formats lines by replacing newlines ('\n') in the string with calls to Format.pp_force_newline.
link [B0_web.Htmlg.El]
link [B0_std.Os.File]
link ~force ~src p hard links file path p to the file src.
list [B0_web.Jsong]
list el l is l as a generated JSON array whose elements are generated using el.
list [B0_github.Issue]
list auth repo lists the issues for repository repo.
list [B0_std.Conv]
array c converts a list of values converted with c.
list [B0_std.Fmt]
list ~sep pp_v formats list elements.
list_of_search_path [B0_std.Fpath]
list_of_search_path ~sep s parses sep separated file paths from s.
logical_cpu_count [B0_machine]
logical_cpu_count () is the number of logical CPUs on the build machine.
lose_left [B0_std.String]
lose_left sat s is s without the first consecutive sat satisfying bytes of s.
lose_right [B0_std.String]
lose_right sat s is s without the last consecutive sat satisfying bytes of s.
lower_hex_digit [B0_std.Char.Ascii]
lower_hex_digit n is an hexadecimal digit for the integer n truncated to its lowest 4 bits.
lowercase [B0_std.String.Ascii]
lowercase s is s with US-ASCII characters 'A' to 'Z' mapped to 'a' to 'z'.
lowercase [B0_std.Char.Ascii]
lowercase c is c with US-ASCII characters 'A' to 'Z' mapped to 'a' to 'z'.

M
map [B0_web.Htmlg.El]
map [B0_std.String]
map f s is s' with s'.[i] = f s.[i] for all indices i of s.
map [B0_std.Result]
map f r is Ok (f v) if r is Ok v and r if r is Error _.
map [B0_std.Option]
map f o is None if o is None and Some (f v) is o is Some v.
map_error [B0_std.Result]
map_error f r is Error (f e) if r is Error e and r if r is Ok _.
mapi [B0_std.String]
mapi f s is s' with s'.[i] = f i s.[i] for all indices i of s.
mark [B0_web.Htmlg.El]
max_spawn [B0_ui.Memo]
max_spawn jobs determines a maximal number of spans.
media [B0_web.Htmlg.Att]
mem [B0_web.Jsonq]
mem name q o queries a JSON object o's member named name with q.
mem [B0_web.Jsong]
mem name v o is o with member name bound to value v added.
mem [B00.File_cache]
mem c k is true iff k is bound in c.
mem_ext [B0_std.Fpath]
mem_ext exts p is List.exists (fun e -> has_ext e p) exts
mem_if [B0_web.Jsong]
mem_if cond name v o is mem name (v ()) o if cond is true and o otherwise.
mem_opt [B0_web.Jsonq]
mem_opt name q queries a JSON object o's optional member named name with q.
memo [B00.Memo]
memo is a simpler B00.Memo.create hash_fun defaults to B00.Op_cache.create's default., max_spawn defaults to B00.Exec.create's default., env defaults to Os.Env.current, cwd defaults to Os.Dir.cwd, cachedir defaults to Fpath.(cwd / "_b0" / "cache"), feedback defaults formats feedback on stdout.
menu [B0_web.Htmlg.El]
meta [B0_web.Htmlg.El]
meter [B0_web.Htmlg.El]
meth_to_string [B0_web.Http]
meth_to_string m is a string representation of m.
mkdir [B00.Memo]
mkdir m dir k creates directory dir and continues with k () at which point file dir is ready.
mkdir [B00.Op]
mkdir declares a directory creation operation, see the corresponding accessors for the semantics of the various fields.
mode [B00.Op.Write]
int w is the mode of the file written by w.
msg [B0_std.Log]
See Logs.msg.
must_exist [B0_std.Os.Dir]
must_exist dir is Ok () if dir is a directory in the file system and an error otherwise.
must_exist [B0_std.Os.File]
must_exist file is Ok () if file is a regular file in the file system and an error otherwise.
must_exist [B0_std.Os.Path]
must_exist p is Ok () if p exists in the file system and an error otherwise.
must_find [B0_std.Os.Cmd]
must_find ~search cmd resolves cmd's tool as B0_std.Os.Cmd.must_find_tool does.
must_find_tool [B0_std.Os.Cmd]
must_find_tool is like B0_std.Os.Cmd.find_tool except it errors if Ok None is returned.

N
name [B0_web.Htmlg.Att]
name [B0_github.Repo]
name r is r's name.
name [B00.Tool]
name t is t's tool name.
nav [B0_web.Htmlg.El]
need_copy [B00.File_cache]
need_copy c is Some file iff the cache switched to copying mode because of an operation that involved the file path file, external to the cache.
never_files [B00.Guard]
never_files g are the files that never got ready in g.
nil [B0_std.Hash]
nil is the only hash value of B0_std.Hash.length 0.
none [B0_std.Option]
none is None.
none [B0_std.Fmt]
none is unit "<none>".
nop [B0_std.Fmt]
nop formats nothing.
noscript [B0_web.Htmlg.El]
not_dirty [B0_vcs]
not_dirty is Ok () iff the working directory of r is not dirty and an error that enjoins to stash or commit otherwise.
null [B0_web.Jsonq]
null queries a null JSON value.
null [B0_web.Jsong]
null is the generated JSON null value.
null [B0_std.Os.File]
null represents a file on the OS that discards all writes and returns end of file on reads.
nullable [B0_web.Jsonq]
nullable q queries either a null JSON value or with q.
number [B0_github.Issue]
number i is the issue's number.

O
obj [B0_web.Jsonq]
obj v queries an object and returns v.
obj [B0_web.Jsong]
obj is an empty object.
obj_end [B0_web.Jsong]
obj_end o is o as a generated JSON value.
object' [B0_web.Htmlg.El]
ocaml_string_escape [B0_std.String.Ascii]
ocaml_string_escape s escapes the bytes of s to a representation that uses only US-ASCII printable characters and according to OCaml's conventions for string literals.
ocaml_unescape [B0_std.String.Ascii]
ocaml_unescape s unescapes from s the escape sequences afforded by OCaml string and char literals.
of_assignments [B0_std.Os.Env]
of_assignments ~init ss folds over strings in ss, cuts them at the leftmost '=' character and adds the resulting pair to init (defaults to B0_std.Os.Env.empty).
of_bin [B0_std.Conv]
of_bin c s binary decodes a value from s using c.
of_bytes [B0_std.Hash]
of_bytes s is the sequences of bytes of s as a hash value.
of_cache [B00.File_cache.Stats]
of_cache c are satistics of c.
of_char [B0_std.String]
of_char c is c as a string.
of_fd [B0_std.Tty]
of_fd fd determines the terminal for file descriptor fd by using Unix.isatty fd and consulting the TERM environment variable.
of_hex [B0_std.Hash]
of_hex s is Result.map of_bytes (B0_std.String.Ascii.of_hex s).
of_hex [B0_std.String.Ascii]
of_hex h parses a sequence of US-ASCII (lower or upper cased) hexadecimal digits from h into its corresponding byte sequence.
of_keys [B00.File_cache.Stats]
of_keys ks are statistics for ks.
of_list [B0_std.Cmd]
of_list ?slip conv l is B0_std.Cmd.args ?slip (List.map conv l).
of_list [B0_std.Fpath.Map]
of_list bs is List.fold_left (fun m (k, v) -> add k v m) empty bs.
of_list [B0_std.String.Map]
of_list bs is List.fold_left (fun m (k, v) -> add k v m) empty bs.
of_ops [B0_trace.Compilation_database]
of_ops [B0_trace.Trace_event]
of_rev_list [B0_std.Cmd]
of_rev_list ?slip conv l is B0_std.Cmd.args ?slip (List.rev_map conv l).
of_string [B0_web.Json]
of_string s parses JSON text from s according to RFC8259 with the following limitations: Numbers are parsed with string_of_float which is not compliant., Unicode escapes are left unparsed (this will not round trip with B0_web.Json.to_string).
of_string [B0_std.Cmd]
of_string s tokenizes s into a command line.
of_string [B0_std.Fpath]
of_string s is the string s as a path.
of_txt [B0_std.Conv]
of_txt c s textually decodes a value from s using c.
of_uint64_ns [B0_std.Time.Span]
of_uint64_ns u is the unsigned 64-bit integer nanosecond span u as a span.
ok [B0_std.Result]
ok v is Ok v.
ol [B0_web.Htmlg.El]
ol
one [B0_std.Time.Span]
one is a span of 1ns.
one_of [B0_std.Fmt]
one_of ~empty pp_v ppf l formats according to the length of l 0, formats empty (defaults to B0_std.Fmt.nop)., 1, formats the element with pp_v., 2, formats "either %a or %a" with the list elements, n, formats "one of %a, ... or %a" with the list elements
op_cache [B00.Memo]
op_cache m is m's operation cache.
open_tmp_fd [B0_std.Os.File]
open_tmp_fd is like B0_std.Os.File.with_tmp_fd except it is the client's duty to close the file descriptor and delete the file (if the file is not deleted it will be when the program exits).
ops [B00.Memo]
ops m is the list of operations that were submitted to the memoizer
optgroup [B0_web.Htmlg.El]
option [B0_web.Htmlg.El]
option [B0_std.Conv]
option c converts optional values converted with c.
option [B0_std.Fmt]
option ~none pp_v formats an option.
out_fd [B0_std.Os.Cmd]
out_fd ~close fd is a standard output that writes to file descriptor fd.
out_file [B0_std.Os.Cmd]
out_file f is a standard output that writes to file f.
out_null [B0_std.Os.Cmd]
out_null is out_file File.null
out_stderr [B0_std.Os.Cmd]
out_stderr is out_fd ~close:false Unix.stderr
out_stdout [B0_std.Os.Cmd]
out_stdout is out_fd ~close:false Unix.stdout
output [B0_web.Htmlg.El]
override [B0_std.Os.Env]
override env ~by:o overrides the definitions in env by o.
owner [B0_github.Repo]
owner r is r's owner.

P
p [B0_web.Htmlg.El]
p
page_files [B0_ui.Pager]
page_files pager fs uses pager to page the files fs.
page_stdout [B0_ui.Pager]
page_stdout pager setups the program so that if pager is Some cmd, the standard output of the program is redirected to a spawn of cmd with the following twists: If the environment variable LESS is undefined in the current environment it is set to LESS=FRX for the spawn of cmd., A Pervasive.at_exit function is installed that flushes Fmt.stdout and stdout, closes Unix.stdout and waits upon the cmd spawn termination. If pager is None this function has no effect.
pair [B0_std.Conv]
pair c0 c1 converts pairs of values converted with c0 and c1.
pair [B0_std.Fmt]
pair ~sep pp_fst pp_snd formats a pair.
param [B0_web.Htmlg.El]
parens [B0_std.Fmt]
parens pp_v ppf is pf ppf "@[<1>(%a)@]" pp_v.
parent [B0_std.Fpath]
parent p is a directory path that contains p.
path [B0_web.Jsong]
path p is p as a generated JSON string value.
path [B0_ui.B0_std.Arg]
path is a converter for file paths.
path [B0_std.Cmd]
path p is arg (Fpath.to_string p).
path_list [B0_std.Os.Dir]
path_list is a folding function to get a (reverse w.r.t.
paths [B0_std.Cmd]
paths ?slip ps is B0_std.Cmd.of_list ?slip Fpath.to_string ps.
perform [B0_web.Http]
perform curl r performs request r via curl which is looked up in the PATH or in the environment variable B0_CURL.
pf [B0_std.Fmt]
pf is Format.fprintf.
pid_to_int [B0_std.Os.Cmd]
pid_to_int pid is the system identifier for process identifier pid.
placeholder [B0_web.Htmlg.Att]
pp [B0_vcs]
pp formats a repository.
pp [B0_github.Release]
pp is a formatter for issues.
pp [B0_github.Issue]
pp is a formatter for issues.
pp [B00.Op.Mkdir]
pp formats directory creations.
pp [B00.Op.Write]
pp formats a write.
pp [B00.Op.Read]
pp formats a read.
pp [B00.Op.Spawn]
pp formats a spawn.
pp [B00.Op]
pp formats a build operation.
pp [B00.File_cache.Stats]
pp formats cache statistics.
pp [B0_std.Cmd]
pp ppf l formats an unspecified representation of l on ppf.
pp [B0_std.Time.Span]
pp formats with B0_std.Fmt.uint64_ns_span.
pp [B0_std.Hash]
pp formats using B0_std.Hash.to_hex or, if the hash is B0_std.Hash.nil, formats "nil".
pp [B0_std.Fpath.Map]
pp ~sep pp_binding ppf m formats the bindings of m on ppf.
pp [B0_std.Fpath.Set]
pp ~sep pp_elt ppf ss formats the elements of ss on ppf.
pp [B0_std.Fpath]
pp ppf p prints path p on ppf using B0_std.Fpath.to_string.
pp [B0_std.String.Map]
pp ~sep pp_binding ppf m formats the bindings of m on ppf.
pp [B0_std.String.Set]
pp ~sep pp_elt ppf ss formats the elements of ss on ppf.
pp [B0_std.String]
pp ppf s prints s's bytes on ppf.
pp_cmd [B00.Op.Spawn]
pp_cmd formats the command issued by the spawn.
pp_cmd_status [B0_std.Os.Cmd]
pp_cmd_status is a formatter for command process exit statuses.
pp_did_not_write [B00.Op]
pp_did_not_write formats a build operation and the files it failed to write.
pp_feedback [B00.Memo]
pp_feedback ppf formats feedback.
pp_feedback [B00.Exec]
pp_feedback formats executor feedback.
pp_feedback [B00.File_cache]
pp_feedback formats file caches feedback.
pp_keys [B00.File_cache.Stats]
pp_keys formats key statistics.
pp_kind [B0_vcs]
pp_kind formats types of VCS.
pp_level [B0_std.Log]
pp_level ppf l prints and unspecified representation of l on ppf.
pp_ns [B0_std.Time.Span]
pp_ns ppf s prints s as an unsigned 64-bit integer nanosecond span.
pp_quoted [B0_std.Fpath]
pp_quoted p prints path p on ppf using Filename.quote.
pp_result [B00.Op.Mkdir]
pp_result formats directory creation results.
pp_result [B00.Op.Write]
pp_result formats a write result.
pp_result [B00.Op.Read]
pp_result formats the read result.
pp_result [B00.Op.Spawn]
pp_result formats the command status of the spawn.
pp_short [B0_github.Release]
pp_short is a short formatter for issues.
pp_short [B0_github.Issue]
pp_short is a short formatter for issues.
pp_short [B00.Op]
pp_short formats a build operation on a single line.
pp_spawn_status_fail [B00.Op]
pp_spawn_status_fail formats a spawn operation failure due to exit result.
pp_stats [B0_ui.Memo]
pp_stats formats statistics about the memoizer.
pp_status [B00.Op]
pp_status formats execution status.
pp_status [B0_std.Os.Cmd]
pp_status is a formatter for process exit statuses.
pp_stdo_ui [B00.Op.Spawn]
pp_stdo_ui formats the standard output ui of the spawn.
pp_success_exits [B00.Op.Spawn]
pp_success_exits formats the success exits.
pr [B0_std.Fmt]
pf is Format.printf.
pre [B0_web.Htmlg.El]
prefix [B0_ui.Browser]
prefix is --prefix option to use the prefix argument of B0_ui.Browser.show.
progress [B0_web.Htmlg.El]

Q
q [B0_web.Htmlg.El]
q
query [B0_web.Jsonq]
query q j queries a JSON value j with q.
query_v4 [B0_github.Repo]
query_v4 auth r q performs the subgraph query q on repo r using authentication auth.
query_v4 [B0_github]
query_v4 auth q performs the the GitHub GraphQL V4 query q using authentication auth.
quiet [B0_std.Log]
quiet is msg Quiet.

R
read [B00.Memo]
read m file k reads the contents of file file as s when it becomes ready and continues with k s.
read [B00.Op]
read declares a file read operation, see the corresponding accessors in B00.Op.Read for the semantics of the various fields.
read [B0_std.Os.File]
read file is file's content as a string.
read_env [B00.Tool]
read_env t env is (all, relevant) with all the environment with the variables of env that are in vars t and shielded_vars t and relevant those of vars t only.
read_file [B0_std.Os.Fd]
read_file fn fd reads fd to a string assuming it is a file descriptor open on file path fn.
read_with_fd [B0_std.Os.File]
read_with_ic file f opens file as a file descriptor fdi and returns Ok (f ic).
read_with_ic [B0_std.Os.File]
read_with_ic file f is exactly like B0_std.Os.File.read_with_fd but opens an OCaml input channel.
reads [B00.Op]
reads o are the file paths read by the operation.
ready_files [B00.Guard]
ready_files g are the files that got ready in g.
rel [B0_web.Htmlg.Att]
relevant_env [B00.Op.Spawn]
relevant_env s are the assignements of env s that should be taken into account for caching.
rem [B00.File_cache]
rem c k removes the binding of k in c.
rem_ext [B0_std.Fpath]
rem_ext ?multi p is p with the extension of p's basename removed.
remote_branch_delete [B0_vcs.Git]
remote_branch_delete r ~remote ~branch deletes branch on remote.
remote_branch_exists [B0_vcs.Git]
remote_branch_exists r remote branch asserts whether branch exists on remote.
remote_branch_fetch [B0_vcs.Git]
remote_branch_fetch r remote branch fetches branch of remote.
remote_branch_push [B0_vcs.Git]
remote_branch_push r ~force ~local ~remote ~dst pushes branch src on dst of remote.
rename [B0_std.Os.Path]
rename ~force ~make_path ~src dst renames src to dst.
repo_dir [B0_vcs]
repo_dir r is r's repository directory (not the working directory).
req [B0_web.Http]
req uri m ~headers ~body is a request on uri with method m, headers headers (defaults to []) and body body (defaults to "").
req_body [B0_web.Http]
req_body r is r's body.
req_headers [B0_web.Http]
req_headers r is r's headers.
req_json_v3 [B0_github.Repo]
req_json_v3 is like B0_github.Repo.req_json_v3 but performs given the root subpath on the given repo.
req_json_v3 [B0_github]
req_json_v3 auth path m ~headers body performs the request for json on path using method m, additional headers headers, body body and authentication auth.
req_meth [B0_web.Http]
req_meth r is r's HTTP method.
req_uri [B0_web.Http]
req_uri r is r's request URI.
resp_body [B0_web.Http]
resp_body r is the HTTP response body.
resp_headers [B0_web.Http]
resp_headers r are the HTTP response headers.
resp_status [B0_web.Http]
resp_status r is the HTTP response status.
response_file [B00.Tool]
response_file t is t's response file specification (if any).
response_file_of [B00.Tool]
response_file_of to_file cli is a response file specification that uses to_file cmd to convert the command line cmd to a response file content and cli f a command line fragment to be given to the tool so that it treats file f as a response file.
result [B00.Op.Mkdir]
result mk is unit or an error.
result [B00.Op.Write]
result w is the result of the file write.
result [B00.Op.Read]
result r is the contents of the read file or an error.
result [B00.Op.Spawn]
result s is the spawn result of s.
result [B0_std.Conv]
result ok error converts result values with ok and error.
rev_args [B0_std.Cmd]
rev_args ?slip l is B0_std.Cmd.args ?slip (List.rev l).
rev_paths [B0_std.Cmd]
rev_paths ?slip ps is B0_std.Cmd.of_rev_list ?slip Fpath.to_string ps.
revive [B00.Op_cache]
revive c o tries to revive operation o from the file cache using the key Op.hash o.
revive [B00.File_cache]
revive c k fs binds the file contents of key k to the inexistent file paths (directories are created) of fs.
rm [B0_vcs.Git]
rm r ~force ~recurse ~ignore_unmatch files removes files from the working tree and from the index.
root_undecided_files [B00.Guard]
root_undecided_file g is like B00.Guard.undecided_files but has only the files that are not written by a guarded_op of g.
rp [B0_web.Htmlg.El]
rp
rt [B0_web.Htmlg.El]
rt
ruby [B0_web.Htmlg.El]
run [B0_std.Os.Cmd]
run is B0_std.Os.Cmd.run_status with non-`Exited 0 statuses turned into errors via B0_std.Os.Cmd.pp_cmd_status.
run_out [B0_std.Os.Cmd]
run is B0_std.Os.Cmd.run_status_out with non-`Exited 0 statuses turned into errors via B0_std.Os.Cmd.pp_cmd_status.
run_status [B0_std.Os.Cmd]
run_status ~env ~cwd ~stdin ~stdout ~stderr cmd runs and waits for the completion of cmd in environment env with current directory cwd and standard IO connections stdin, stdout and stderr.
run_status_out [B0_std.Os.Cmd]
run_status_out is like B0_std.Os.Cmd.run_status except stdout is read from the process to a string.
runtime [B0_std.Os.Dir]
runtime () is the directory used to store user-specific runtime files.

S
s [B0_web.Htmlg.El]
s
salt [B00.Op.Write]
salt w is the file write salt used for caching.
samp [B0_web.Htmlg.El]
schedule [B00.Exec]
schedule e o schedules o for execution in e.
script [B0_web.Htmlg.El]
search_path_sep [B0_std.Fpath]
search_path_sep is the default platform specific separator for search paths, this is ";" if Sys.win32 is true and ":" otherwise.
section [B0_web.Htmlg.El]
sel [B0_web.Jsonq]
sel name q is obj get |> mem name q
select [B0_web.Htmlg.El]
set [B00.Memo.Fut]
set s v sets the future value linked to s to the value v.
set_cwd [B0_std.Os.Dir]
set_cwd dir sets the current working directory to dir.
set_default_tmp [B0_std.Os.Dir]
set_default_tmp p sets the value returned by B0_std.Os.Dir.default_tmp to p.
set_exec_end_time [B00.Op]
set_exec_end_time o t sets o's execution end time to s.
set_exec_start_time [B00.Op]
exec_start_time o t sets o's execution start time to t.
set_ext [B0_std.Fpath]
set_ext ?multi p is add_ext ext (rem_ext ?multi p).
set_file_never [B00.Guard]
set_file_never g f indicate to g that file f will never become ready.
set_file_ready [B00.Guard]
set_file_ready g f indicates to g that file f is ready, i.e.
set_hash [B00.Op]
set_hash o h sets the operation hash to h.
set_kmsg [B0_std.Log]
set_kmsg kmsg sets the logging function to kmsg.
set_level [B0_std.Log]
set_level l sets the current reporting level to l.
set_mode [B0_std.Os.Path]
set_mode file p sets the file mode of file to p.
set_op_hash [B00.Op_cache]
set_op_hash t o hashes the operation o and stores the result in o with B00.Op.set_hash.
set_reads [B00.Op]
set_reads t fs sets the file paths read by o to fs.
set_result [B00.Op.Mkdir]
set_result r res sets the mkdir result of r to res.
set_result [B00.Op.Write]
set_result w res sets the write results of w to res.
set_result [B00.Op.Read]
set_result r res sets the file read result of r to res.
set_result [B00.Op.Spawn]
set_result s e the spawn result of s to e.
set_spawn_tracer [B0_std.Os.Cmd]
set_tracer t sets the current spawn tracer to t.
set_status [B00.Op]
set_status o s sets the execution status to s.
set_stdo_ui [B00.Op.Spawn]
set_stdo_ui w ui sets w's standard output redirection contents to ui.
set_tool [B0_std.Cmd]
set_tool tool l replaces l's first element with tool.
set_tty_styling_cap [B0_std.Fmt]
set_tty_styling_cap c sets the global styling capabilities to c.
set_writes [B00.Op]
set_writes t fs sets the file paths written by o to fs.
setup [B0_ui.B0_std]
setup ~docs ~trace_spawns_on_debug ~color_env ~verbosity_env () uses B0_ui.B0_std.color and B0_ui.B0_std.verbosity to setup: B0_std.Fmt.set_tty_styling_cap, using Tty.of_fd on Unix.stdout if B0_ui.B0_std.color is None., B0_std.Log.set_level with B0_ui.B0_std.verbosity., log_spawns log B0_std.Os.Cmd spawns by setting up a B0_std.Os.Cmd.spawn_tracer that traces with the given level. If Level.Quiet is specified no tracer is registered. Defaults to B0_std.Log.Debug. docs is where the section in which the options are documented and color_env and verbosity_env are used with the env argument of B0_ui.B0_std.color and B0_ui.B0_std.verbosity.
shield [B0_std.Cmd]
shield l indicates that arguments l do not influence the tool's invocation outputs.
shielded_vars [B00.Tool]
shieled_vars t are the shielded environment variables accessed by t.
show [B0_ui.Browser]
show ~background ~prefix browser uri shows URI using browser browser (if None an error message is returned mentioning that no browser was found.
si_size [B0_std.Fmt]
si_size ~scale unit formats a non negative integer representing unit unit at scale 10scale * 3, depending on its magnitude, using power of 3 SI prefixes (i.e.
small [B0_web.Htmlg.El]
some [B0_std.Conv]
some c wraps decodes of c with B0_std.Option.some.
some [B0_std.Option]
some v is Some v.
source [B0_web.Htmlg.El]
sp [B0_std.Fmt]
sp is Format.pp_print_space.
span [B0_web.Htmlg.El]
span_left [B0_std.String]
span_left sat s is (keep_left sat s, lose_left sat s).
span_right [B0_std.String]
span_right sat s is (lose_right sat s, keep_right sat s).
spath [B0_std.Cmd]
spath p is shield (path p).
spawn [B00.Memo]
spawn m ~reads ~writes ~env ~cwd ~stdin ~stdout ~stderr ~success_exits cmd spawns cmd once reads files are ready and makes files writes ready if the spawn succeeds and the file exists.
spawn [B00.Op]
spawn declares a spawn build operation, see the corresponding accessors in B00.Op.Spawn for the semantics of the various fields.
spawn [B0_std.Os.Cmd]
spawn ~env ~cwd ~stdin ~stdout ~stderr cmd spawns command cmd in environment env with current directory cwd and standard IO connections stdin, stdout and stderr.
spawn_poll_status [B0_std.Os.Cmd]
spawn_poll_status pid tries to collect the exit status of command spawn pid.
spawn_tracer [B0_std.Os.Cmd]
tracer () is the current spawn tracer.
spawn_tracer_nop [B0_std.Os.Cmd]
spawn_tracer_nop is a spawn tracer that does nothing.
spawn_wait_status [B0_std.Os.Cmd]
spawn_wait_status blocks and waits for pid's termination status to become available.
splice [B0_web.Htmlg.El]
splice cs when added to a child list splices cs into the list.
squotes [B0_std.Fmt]
squotes pp_v is pf "'%a'" pp_v
src [B0_web.Htmlg.Att]
stat [B0_std.Os.Path]
stat p is p's file information.
status [B00.Op]
status o is o execution status.
stderr [B00.Op.Spawn]
stderr s is the redirection s uses for stderr.
stderr [B0_std.Fmt]
stderr outputs to standard error.
stdin [B00.Op.Spawn]
stdin s is the file s uses as stdin (if any).
stdo_ui [B00.Op.Spawn]
stdo_ui sr is the standard outputs redirection contents of s once it has executed (if any).
stdout [B00.Op.Spawn]
stdout s is the redirection s uses for stdout.
stdout [B0_std.Fmt]
stdout outputs to standard output.
stir [B00.Memo]
stir ~block m runs the memoizer a bit.
str [B0_std.Fmt]
str is Format.asprintf.
strf [B0_web.Jsong]
strf fmt ... is a JSON string generated value formatted according to fmt.
string [B0_web.Jsonq]
string queries a string JSON value.
string [B0_web.Jsong]
str s is s as a generated JSON string value.
string [B0_std.Hash.T]
string s is the hash of s.
string [B0_std.Fmt]
string is Format.pp_print_string.
string_bytes [B0_std.Conv]
string_bytes converts OCaml strings as byte sequences.
string_only [B0_std.Conv]
string_only converts OCaml strings.
strip_escapes [B0_std.Tty]
strip_escapes s removes ANSI escapes from s.
strong [B0_web.Htmlg.El]
style [B0_web.Htmlg.El]
styled_str [B0_std.Tty]
styled_str cap styles s styles s according to styles and cap.
sub [B0_web.Htmlg.El]
success_exits [B00.Op.Spawn]
success_exits s is the list of process exit codes s that indicate success.
suggest [B0_std.String]
suggest ~dist candidates s are the elements of candidates whose edit distance is the smallest to s and at most at a distance of dist of s (defaults to 2).
summary [B0_web.Htmlg.El]
sup [B0_web.Htmlg.El]
symlink [B0_std.Os.Path]
symlink ~force ~src p symbolically links src to p.
symlink_link [B0_std.Os.Path]
symlink_link p is Ok l if p is a symbolic link to l.
symlink_stat [B0_std.Os.Path]
symlink_stat p is like B0_std.Os.Path.stat but if p is a symlink returns information about the link itself.
sys_signal [B0_std.Fmt]
sys_signal formats an OCaml signal number as a C POSIX constant or "SIG(%d)" if the signal number is unknown.

T
tabindex [B0_web.Htmlg.Att]
table [B0_web.Htmlg.El]
tag [B0_vcs]
tag r ~force ~sign ~msg commit_ish t tags commit_ish with t and message msg (if unspecified the VCS should prompt).
tag_name [B0_github.Release]
tag_name r is the tag name of the release.
tags [B0_vcs]
tags r is the list of tags in the repo r.
take_left [B0_std.String]
take_left n s are the first n bytes of s.
take_right [B0_std.String]
take_right n s are the last n bytes of s.
tbody [B0_web.Htmlg.El]
td [B0_web.Htmlg.El]
td
text [B0_std.Fmt]
text is Format.pp_print_text.
textarea [B0_web.Htmlg.El]
tfoot [B0_web.Htmlg.El]
th [B0_web.Htmlg.El]
th
thead [B0_web.Htmlg.El]
time [B0_web.Htmlg.El]
time [B0_std.Log]
time ~level m f logs m with level level (defaults to Info) and the time f () took as the log header.
title [B0_web.Htmlg.El]
title [B0_web.Htmlg.Att]
title [B0_github.Issue]
title i is the issue's title.
tmp [B0_std.Os.Dir]
tmp is like B0_std.Os.Dir.with_tmp except the directory and its content is only deleted at the end of program execution if the client doesn't do it before.
tmp [B0_std.Os.Path]
tmp ~make_path ~dir name () is a file system path in dir that did not exist when the name was found.
tmp_vars [B00.Tool]
tmp_vars is ["TMPDIR"; "TEMP"; "TMP"].
to_assignments [B0_std.Os.Env]
to_assignments env is env's bindings as assignments.
to_bin [B0_std.Conv]
to_bin c v binary encodes v using c.
to_bytes [B0_std.Hash]
to_bytes h is the sequence of bytes of h.
to_dir_path [B0_std.Fpath]
to_dir_path p is add_seg p "".
to_failure [B0_std.Result]
to_failure r is failwith e if r is Error e and v if r is Ok v.
to_hex [B0_std.Hash]
to_hex h is B0_std.String.Ascii.to_hex (to_bytes h).
to_hex [B0_std.String.Ascii]
to_hex s is the sequence of bytes of s as US-ASCII lowercase hexadecimal digits.
to_list [B0_std.Cmd]
to_list l converts l to a list of strings.
to_list [B0_std.Result]
to_list r is [v] if r is Ok v and [] otherwise.
to_list [B0_std.Option]
to_list o is [] if o is None and [v] if o is Some v.
to_list_and_sig [B0_std.Cmd]
to_list_and_sig l is a l as a list of strings tuppled with its signature: the sequence of unshielded arguments.
to_option [B0_std.Result]
to_option r is r as an option, mapping Ok v to Some v and Error _ to None.
to_pp [B0_std.Conv]
to_pp c is a formatter using B0_std.Conv.to_txt to format values.
to_result [B0_std.Option]
to_result ~none o is Ok v if o is Some v and Error none otherwise.
to_sig [B0_std.Cmd]
to_sig l is the sequence of unshielded arguments.
to_string [B0_web.Jsong]
to_string g is the generated JSON value g as a string.
to_string [B0_web.Json]
to_string v is v as JSON text, encoded according to RFC8259
to_string [B0_web.Htmlg.El]
to_string is like B0_web.Htmlg.El.buffer_add but returns directly a string.
to_string [B0_std.Os.Fd]
to_string fd reads fd to a string.
to_string [B0_std.Cmd]
to_string l converts l to a string that can be passed to the command(3) POSIX system call.
to_string [B0_std.Fpath]
to_string p is the path p as a string.
to_txt [B0_std.Conv]
to_txt c v textually encodes v using c.
to_uint64_ns [B0_std.Time.Span]
to_uint64_ns s is s as an unsigned 64-bit integer nanosecond span.
tool [B00.Memo]
tool m t is tool t memoized.
tool [B00.Env]
tool e t looks up tool t in e.
tool [B00.Op.Spawn]
tool t is the spawned tool.
tool [B0_std.Cmd]
tool l is l's first element.
tr [B0_web.Htmlg.El]
tr
track [B0_web.Htmlg.El]
tracked_files [B0_vcs]
tracked_files ~tree_ish r are the files tracked by the tree object tree_ish.
transient_checkout [B0_vcs.Git]
checkout_tmp_branch r ~force ~branch dir commit_ish creates and checkouts and a branch branch in dir that points to commit_ish (if None an orphan branch is created).
transient_checkout_delete [B0_vcs.Git]
transient_checkout_delete r deletes a transient checkout.
trim_size [B00.File_cache]
trim_size c max_byte_size ~pct delete keys of c until they either weight at most max_byte_size or are pct of their current size; whichever is the smaller.
truncate [B0_std.Os.File]
trunacte file size truncates file to size.
tty [B0_std.Fmt]
tty styles pp_v ppf v prints v with pp_v on ppf according to styles and the value of B0_std.Fmt.tty_styling_cap.
tty_str [B0_std.Fmt]
tty_str styles ppf s prints s on ppf according to styles and the value of B0_std.Fmt.tty_styling_cap.
tty_styling_cap [B0_std.Fmt]
tty_styling_cap () is the global styling capability.
txt [B0_web.Htmlg.El]
txt d is character data d.
txt_dec [B0_std.Conv]
txt_dec c is the textual decoder of c.
txt_enc [B0_std.Conv]
txt_enc c is the textual encoder of c.
type' [B0_web.Htmlg.Att]

U
u [B0_web.Htmlg.El]
u
uint64_ns_span [B0_std.Fmt]
uint64_ns_span formats an unsigned nanosecond time span according to its magnitude using SI prefixes on seconds and accepted non-SI units.
ul [B0_web.Htmlg.El]
ul
uncapitalize [B0_std.String.Ascii]
uncapitalize s is like B0_std.String.Ascii.lowercase but performs the map only on s.[0].
undecided_files [B00.Guard]
undecided_files g are the files that are neither got ready nor never got ready in g.
unescape [B0_std.String.Ascii]
unescape s unescapes from s the escapes performed by B0_std.String.Ascii.escape.
unescaper [B0_std.String]
unescaper char_len_at set_char is a byte unescaper that uses char_len_at to determine the length of a byte at a given index in the string to unescape and set_char b k s i to set at index k in b the unescaped character read at index i in s; and returns the next readable index in s (no bound check need to be performed).
unique [B0_std.String]
unique ~exist n is n if exists n is false or r = strf "%s~%d" n d with d the smallest integer in [1;1e9] such that exists r is false or an error if there is no such string.
uniquify [B0_std.Fpath]
uniquify ps is ps without duplicates, the list order is preserved.
uniquify [B0_std.String]
uniquify ss is ss without duplicates, the list order is preserved.
unit [B0_std.Fmt]
unit fmt formats a unit value with the format fmt.
unix_buffer_size [B0_std.Os.Fd]
unix_buffer_size is the value of the OCaml runtime system buffer size for I/O operations.
unused_keys [B00.File_cache.Stats]
unused_keys s are statistics about unused keys in the cache.
update [B0_github.Pages]
replace_dirs vcs ~remote ~branch ~msg us updates branch (defaults to gh-pages) on remote according to us (see B0_github.Pages.update) with commit mesage msg.
upload_asset [B0_github.Release]
upload_asset auth repo r ~content_type ~name asset uploads assets content asset with file name name and content type content_type in release r of repo r.
upper_hex_digit [B0_std.Char.Ascii]
upper_hex_digit n is an hexadecimal digit for the integer n truncated to its lowest 4 bits.
uppercase [B0_std.String.Ascii]
uppercase s is s with US-ASCII characters 'a' to 'z' mapped to 'A' to 'Z'.
uppercase [B0_std.Char.Ascii]
uppercase c is c with US-ASCII characters 'a' to 'z' mapped to 'A' to 'Z'.
url [B0_github.Issue]
url i is the issue's url.
user [B0_std.Os.Dir]
user () is the home directory of the user executing the process.

V
v [B0_web.Htmlg.El]
v n ~a cs is an element with name n, attributes a (defaults to []) and children cs.
v [B0_web.Htmlg.Att]
v n value is an attribute named n with value value.
v [B0_github.Repo]
repo ~owner name identifiers a GitHub repository.
v [B00.Tool]
v ~response_file ~shielded_vars ~vars cmd is a tool specified by cmd.
v [B00.Env]
v ~lookup ~forced_env env is a build environment with: lookup used to find build tools. Defaults to env_tool_lookup env., forced_env is environment forced on any tool despite what it declared to access, defaults to Os.Env.empty, env the environment read by the tools' declared environment variables.
v [B0_std.Fpath]
v s is the string s as a path.
v [B0_std.Conv]
v ~kind ~docvar bin_enc bin_dec txt_enc txt_dec is a value converter using bin_enc, bin_dec, txt_enc, txt_dec for binary and textual conversions.
value [B0_web.Htmlg.Att]
value [B00.Memo.Fut]
value f is f's value if set.
value [B0_std.Result]
value r ~default is v if r is Ok v and default otherwise.
value [B0_std.Option]
value o ~default is v if o is Some v and default otherwise.
var [B0_web.Htmlg.El]
vars [B00.Tool]
vars t are the relevant environment variables accessed by t.
vbox [B0_std.Fmt]
vbox is like B0_std.Fmt.box but is a vertical box: every break hint leads to a new line which adds indent to the current indentation (default to 0).
verbosity [B0_ui.B0_std]
verbosity ~docs ~env () is a cli interface for specifiying the logging level.
video [B0_web.Htmlg.El]

W
wait [B00.Memo.Fut]
wait f k waits for f to be set and continues with k v with v the value of the future.
wait_files [B00.Memo]
wait_files m files k continues with k () when files become ready.
wait_files [B00.Op]
wait_files declares a wait files operation, these are stored in B00.Op.reads.
warn [B0_std.Log]
warn is msg Warning.
warn_count [B0_std.Log]
warn_count () is the number of messages logged with level Warning.
warn_if_error [B0_std.Log]
warn_if_error is if_error ~level:Warning.
wbr [B0_web.Htmlg.El]
width [B0_web.Htmlg.Att]
with_conv [B0_std.Conv]
with_conv ~kind ~docvar to_t of_t t_conv is a converter for type 'b given a converter t_conv for type 'a and conversion functions from and to type 'b.
with_cwd [B0_std.Os.Dir]
with_cwd dir f is f () with the current working directory bound to dir.
with_docvar [B0_std.Conv]
with_docvar docvar c is c with documentation meta-variable docvar.
with_index_range [B0_std.String]
with_index_range ~first ~last s are the consecutive bytes of s whose indices exist in the range [first;last].
with_kind [B0_std.Conv]
with_kind ~docvar k c is c with kind k and documentation meta-variable docvar (defaults to docvar c).
with_tmp [B0_std.Os.Dir]
with_tmp ~mode ~make_path ~dir ~name f creates a temporary empty directory t and returns Ok (f t).
with_tmp_fd [B0_std.Os.File]
with_tmp_fd ~flags ~mode ~make_path ~dir ~name f opens an output file descriptor fdo to a temporary file and returns Ok (f fdo).
with_tmp_oc [B0_std.Os.File]
with_tmp_oc is like B0_std.Os.File.with_tmp_fd but uses an OCaml output channel instead of a file decriptor.
work_dir [B0_vcs]
work_dir r is r's working directory.
write [B00.Memo]
write m ~reads file w writes file with data w () and mode mode (defaults to 0o644) when reads are ready.
write [B00.Op]
write declares a file write operations, see the corresponding accessors in B00.Op.Write for the semantics of the various fields.
write [B0_std.Os.File]
write ~atomic ~mode ~force ~make_path file s operates like B0_std.Os.File.write_with_fd but directly writes s to file.
write_with_fd [B0_std.Os.File]
write_with_fd ~atomic ~mode ~force ~make_path file f opens an output file descriptor fdo to write to file and returns Ok (f fdo).
write_with_oc [B0_std.Os.File]
write_with_oc ~atomic ~mode ~force ~make_path file f operates like B0_std.Os.File.write_with_fd but opens an OCaml channel.
writes [B00.Op]
writes o are the file paths written by o.

Z
zero [B0_std.Time.Span]
zero is a span of 0ns.