Index of values

(+) [Fpath]
p + ext is add_ext ext p.
(-+) [Fpath]
p -+ ext is set_ext ext p.
(/) [Fpath]
p / seg is Fpath.add_seg p seg.
(//) [Fpath]
p // p' is Fpath.append p p'.

add_ext [Fpath]
add_ext ext p is p with the string ext concatenated to p's basename, if non empty.
add_seg [Fpath]
add_seg p seg adds segment seg to the segments of p if p's last segment is non-empty or replaces the last empty segment with seg.
append [Fpath]
append p q appends q to p as follows: If q is absolute or has a non-empty volume then q is returned., Otherwise appends q's segments to p using Fpath.add_seg. Examples.

base [Fpath]
base p is snd (split_base p).
basename [Fpath]
basename p is p's last non-empty segment if non-relative or the empty string otherwise.

choose [Fpath.Map]
Exception safe Map.S.choose.
choose [Fpath.Set]
Exception safe Set.S.choose.
compare [Fpath]
compare p p' is a total order on paths compatible with Fpath.equal.

dir_sep [Fpath]
dir_sep is the platform dependent natural directory separator.
dom [Fpath.Map]
dom m is the domain of m.
dump [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 [Fpath.Set]
dump ppf ps prints an unspecified representation of ps on ppf.
dump [Fpath]
dump ppf p prints path p on ppf using String.dump.

equal [Fpath]
equal p p' is true if p and p' have the same volume are both relative or absolute and have the same segments.
exists_ext [Fpath]
exists_ext ~multi p is true iff p's basename file extension is not empty.

filename [Fpath]
filename p is the file name of p.
find [Fpath.Map]
Exception safe Map.S.find.
find [Fpath.Set]
Exception safe Set.S.find.
find_prefix [Fpath]
find_prefix p p' is Some prefix if there exists prefix such that prefix is the longest path with is_prefix prefix p && is_prefix prefix p' = true and None otherwise.

get [Fpath.Map]
get k m is like Map.S.find but raises Invalid_argument if k is not bound in m.
get [Fpath.Set]
get is like Set.S.find but
get_any_binding [Fpath.Map]
get_any_binding is like Fpath.Map.choose but
get_any_elt [Fpath.Set]
get_any_elt is like Fpath.Set.choose but
get_ext [Fpath]
get_ext p is p's basename file extension or the empty string if there is no extension.
get_max_binding [Fpath.Map]
get_min_binding is like Fpath.Map.max_binding but
get_max_elt [Fpath.Set]
get_max_elt is like Fpath.Set.max_elt but
get_min_binding [Fpath.Map]
get_min_binding is like Fpath.Map.min_binding but
get_min_elt [Fpath.Set]
get_min_let is like Fpath.Set.min_elt but

has_ext [Fpath]
has_ext e p is true iff get_ext p = e || get_ext ~multi:true p = e.

is_abs [Fpath]
is_abs p is true iff p is an absolute path, i.e.
is_current_dir [Fpath]
is_current_dir p is true iff p is the current relative directory, i.e.
is_dir_path [Fpath]
is_dir_path p is true iff p represents a directory.
is_dotfile [Fpath]
is_dotfile p is true iff p's basename is non empty and starts with a '.'.
is_file_path [Fpath]
is_file_path p is true iff p represents a file.
is_parent_dir [Fpath]
is_parent_dir p is true iff p is the relative parent directory, i.e.
is_prefix [Fpath]
is_prefix prefix p is true if prefix is a prefix of p.
is_rel [Fpath]
is_rel p is true iff p is a relative path, i.e.
is_rel_seg [Fpath]
is_rel_seg s is true iff s is a relative segment, that is "." or "..".
is_root [Fpath]
is_root p is true iff p is a root directory, i.e.
is_rooted [Fpath]
is_rooted root p is true iff the path p is the directory root or contained in root and that p can be relativized w.r.t.
is_seg [Fpath]
is_seg s is true iff s does not contain Fpath.dir_sep or '/' or a 0x00 byte.

max_binding [Fpath.Map]
Exception safe Map.S.max_binding.
max_elt [Fpath.Set]
Exception safe Set.S.max_elt.
mem_ext [Fpath]
mem_ext exts p is List.mem (get_ext p) exts || List.mem (get_ext ~multi:true p) exts.
min_binding [Fpath.Map]
Exception safe Map.S.min_binding.
min_elt [Fpath.Set]
Exception safe Set.S.min_elt.

normalize [Fpath]
normalize p is a path that represents the same path as p, directoryness included, and that has the following properties: If p is absolute the resulting path has no "." and ".." segments., If p is relative the resulting path is either "./" or it has no "." segments and ".." segments may only appear as initial segments., If p is a directory it always end with an empty segment; this means it doesn't end with "." or "..". Examples.

of_list [Fpath.Map]
of_list bs is List.fold_left (fun m (k, v) -> add k v m) empty bs.
of_list [Fpath.Set]
of_list ps is a set from the list ps.
of_string [Fpath]
of_string s is the string s as a path.

parent [Fpath]
parent p is a directory path that contains p.
pp [Fpath.Map]
pp ~sep pp_binding ppf m formats the bindings of m on ppf.
pp [Fpath.Set]
pp ~sep pp_elt ppf ps formats the elements of ps on ppf.
pp [Fpath]
pp ppf p prints path p on ppf using Fpath.to_string.

relativize [Fpath]
relativize ~root p is: Some q if there exists a relative path q such that root // q and p represent the same paths, directoryness included. They may however differ syntactically when converted to a string. Note that q is normalized., None otherwise.
rem_empty_seg [Fpath]
rem_empty_seg p removes an existing last empty segment of p if p is not a root path.
rem_ext [Fpath]
rem_ext p is p with the extension of p's basename removed.
rem_prefix [Fpath]
rem_prefix prefix p is: None if prefix is not a prefix of p or if prefix and p are equal., Some q otherwise where q is p without the prefix prefix and preserves p's directoryness. This means that q is a always relative and that the path prefix // q and p represent the same paths. They may however differ syntactically when converted to a string. Examples.

segs [Fpath]
segs p is p's non-empty list of segments.
set_ext [Fpath]
set_ext ?multi ext p is add_ext ext (rem_ext ?multi p).
split_base [Fpath]
split_base p splits p into a directory d and a relative base path b such that: b is a relative path that contains the segments of p that start at the last non-empty segment. This means that b has a single non-empty segment, and preserves directoryness of p. If p is a root path there are no such segments and b is "./"., d is a directory such that d // b represents the same path as p. They may however differ syntactically when converted to a string. Examples.
split_ext [Fpath]
split_ext ?multi p is (rem_ext ?multi p, get_ext ?multi p).
split_volume [Fpath]
split_volume p is the pair (vol, q) where vol is the platform dependent volume of p or the empty string if there is none and q the path p without its volume, that is its optional root Fpath.dir_sep and segments.

to_dir_path [Fpath]
to_dir_path p is Fpath.add_seg p "".
to_string [Fpath]
to_string p is the path p as a string.

v [Fpath]
v s is the string s as a path.