package jenga

  1. Overview
  2. Docs
package jenga
Legend:
Library
Module
Module type
Parameter
Class
Class type
type t

Path.t can be thought of as `abs of string list | `rel of string list with absolute paths `abs l referring to the unix path reachable by following path compoments in l starting from the root ("/") and `rel l referring to the path relative to the jenga root.

Character '/' is disallowed in path components. Path components "" and "." and ".." are disallowed and if used are simplified out.

val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
include Core.Comparable.S with type t := t
include Base.Comparable.S with type t := t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator : (t, comparator_witness) Base__.Comparator.comparator
val validate_lbound : min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound : max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound : min:t Base__.Maybe_bound.t -> max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare : sig ... end
include Core.Hashable.S with type t := t
include Core_kernel.Hashable.Common with type t := t
val compare : t -> t -> Base.Int.t
val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Table : Core_kernel.Hashtbl.S with type key = t
module Hash_set : Core_kernel.Hash_set.S with type elt = t
module Hash_queue : Core_kernel.Hash_queue.S with type Key.t = t
val absolute : string -> t

an absolute path made from a /-separated path string. the string must start with a '/'

val relative : dir:t -> string -> t

a relative path made from a /-separated path string. the string must NOT start with a '/'

val relative_or_absolute : dir:t -> string -> t

either absolute or relative taken w.r.t. dir - determined by leading char

val to_string : t -> string

if relative, displayed as repo-root-relative string. relative_or_absolute ~dir:the_root (to_string t) = t

val the_root : t

refers to the jenga repo root

val unix_root : t

refers to the root of the unix filesystem

val dirname : t -> t

path with the last path component dropped. for the roots (the_root or unix_root) dirname x = x

val basename : t -> string

last component of the path. for the roots we have basename x = "."

val root_relative : string -> t

shortcut for relative ~dir:the_root

val is_descendant : dir:t -> t -> bool

is_descendant ~dir t = true iff there exists a ".."-free x such that relative ~dir x = t

val reach_from : dir:t -> t -> string

x = reach_from ~dir t is such that relative_or_absolute ~dir x = t, x starts with a "." or a '/', and x is otherwise as short as possible

val to_absolute_string : t -> string

returns absolute path string, even if the path is relative. depends on jenga repo location.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct