(+) [Fpath]  p + ext is add_ext ext p .

(+) [Fpath]  p + ext is set_ext ext p .

(/) [Fpath]  
(//) [Fpath]  
A  
add_ext [Fpath]  
add_seg [Fpath]  add_seg p seg adds segment seg to the segments of p if
p 's last segment is nonempty 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 nonempty volume then
q is returned., Otherwise appends q 's segments to p using Fpath.add_seg .
Examples.

B  
base [Fpath]  base p is snd (split_base p) .

basename [Fpath]  basename p is p 's last nonempty segment if nonrelative or
the empty string otherwise.

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

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

E  
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]  
F  
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.

G  
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_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

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

I  
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_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]  
M  
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 .

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

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

P  
parent [Fpath]  
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]  
R  
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_ext [Fpath]  
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.

S  
segs [Fpath]  segs p is p 's nonempty 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 nonempty segment. This means
that b has a single nonempty 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.

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

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