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]
classify [B0_std.List]

classify ~cmp_elts ~cmp_classes ~classes els bins elements els into classes as determined by classes.

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.Cli.Arg]

cmd is a converter for commands.

cmd [B0_odoc.Support_files]

cmd m ~without_theme ~writes ~to_dir writes support files for the HTML to the directory to_dir.

cmd [B0_odoc.Html_fragment]

cmd m ~odoc_deps mld ~o generates an HTML fragment for the mld file mld to file o with the odoc html-fragment command.

cmd [B0_odoc.Html]

cmd m ~hidden ~theme_uri ~odoc_deps ~writes odoc ~to_dir generates HTML for the .odoc file odoc to output directory to_dir with the odoc html command.

cmd [B0_odoc.Compile]

cmd m ~resolve_forward_deps ~hidden ~odoc_deps ~writes ~pkg cobj o compiles the compilation object cobj part of package pkg to destination odoc file o.

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.Cli.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_exists [B0_vcs.Git]

commit_exists r cish checks whether cish exists in r.

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.

commit_updates [B0_github.Pages]

commit_updates vcs ~log ~remote ~branch ~msg us updates branch (defaults to gh-pages) on remote according to updates us with commit message msg.

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.

copy [B0_std.Os.Path]

copy ~make_path ~recurse ~src dst copies the file or file hierarchy rooted at src to dst.

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_branch [B0_github.Pages]

default_branch is "gh-pages", GitHub's default publication branch for GitHub pages.

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.

digest [B0_odoc.Html.Dep]

digest d is the digest of d.

digest [B0_odoc.Compile.Dep]

digest d is the digest of d.

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.

has_staged_changes [B0_vcs.Git]

has_staged_changes r is true if r has staged changes that can be B0_vcs.Git.commited and false otherwise.

hash [B00.Op]

hash o is the operation's hash.

hash_fun [B00.Memo]

hash_fun m is m's hash function.

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.

log_feedback [B0_ui.Memo]

log_feedback ~show_spawn_ui ppf is memo feedback that logs on ppf depending on Log.level.

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_odoc.Html.Dep]

name d is the module name of d.

name [B0_odoc.Compile.Dep]

name d is the module name of d.

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.

nojekyll [B0_github.Pages]

nojekyll is update ~src:(Some Os.File.null) (Fpath.v ".nojekyll").

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.Cli.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.

pkg [B0_odoc.Html.Dep]

pkg d is the package of d.

placeholder [B0_web.Htmlg.Att]
pp [B0_vcs]

pp formats a repository.

pp [B0_odoc.Compile.Dep]

pp formats a dependency.

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_branch [B0_vcs.Git]

pp_branch formats a branch like colorized git would.

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_remote_branch [B0_vcs.Git]

pp_remote_branch formats a remote branch like colorized git would.

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
raw [B0_web.Htmlg.El]

raw s is the raw string s without escaping markup delimiters.

read [B0_odoc.Support_files.Writes]

read m file reads the result of a B0_odoc.Support_files.Writes.write from file and continues with the files that will be written.

read [B0_odoc.Html.Writes]

read m file reads the result of a B0_odoc.Html.Writes.write from file and continues with the files that will be written.

read [B0_odoc.Html.Dep]

read m file reads the result of a B0_odoc.Html.Dep.write from file and continues with the dependencies.

read [B0_odoc.Compile.Writes]

read m file reads the result of a B0_odoc.Compile.Writes.write from file and continues with the files that will be written.

read [B0_odoc.Compile.Dep]

read m file reads the result of a B0_odoc.Compile.Dep.write from file and continues with the dependencies.

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.Cli.B0_std]

setup ~docs ~log_spawns ~color_env ~verbosity_env () uses B0_ui.Cli.B0_std.color and B0_ui.Cli.B0_std.verbosity to setup: B0_std.Fmt.set_tty_styling_cap, using Tty.of_fd on Unix.stdout if B0_ui.Cli.B0_std.color is None., B0_std.Log.set_level with B0_ui.Cli.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.Cli.B0_std.color and B0_ui.Cli.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_compile_dep [B0_odoc.Html.Dep]

to_compile_dep d is d as a compilation depencency (simply drops the B0_odoc.Html.Dep.pkg).

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 [B0_odoc]

tool is the odoc tool.

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 empty 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_string [B0_std.Fmt]

tty_string 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]

update ~follow_symlinks ~src dst is an update that given a relative path dst in the work tree that may not exist: If src is None, deletes dst in the work tree., If src is Some src replaces dst in the work tree by the contents of the file or file hierarchy src. If follow_symlinks is true (default) symbolic links are followed in src. Use . for dst to denote the root of the work tree; for example update ~src:(Some dir) (Fpath.v ".") replaces the whole website by the file hierarchy rooted at dir.

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.Cli.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.

with_transient_checkout [B0_vcs.Git]

with_transient_checkout r ~force ~branch ~dir commit_ish f calls B0_vcs.Git.transient_checkout and then f r with r the repo to act on the checkout.

work_dir [B0_vcs]

work_dir r is r's working directory.

write [B0_odoc.Support_files.Writes]

write m ~without_theme ~to_dir ~o writes to o the support files written to the to_dir directory.

write [B0_odoc.Html.Writes]

write m ~odoc_deps odoc ~to_dir ~o writes to o the files written by an HTML generation of the .odoc file odoc to to_dir.

write [B0_odoc.Html.Dep]

write m ~odoc_files pkg_odoc_dir o writes the odoc dependencies of the package directory pkg_odoc_dir that contains the odoc files odoc_files to o.

write [B0_odoc.Compile.Writes]

write m cobj ~to_odoc ~o writes the files written by a compilation of cobj to to_odoc to o.

write [B0_odoc.Compile.Dep]

write m cobj o writes the odoc dependencies of the compilation object cobj to o.

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.