package grace

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

Source code ranges, also known as 'locations'.

Grace's ranges are opaque byte index intervals of the form [start, stop) (not including the byte at the stop index) within a given source.

A range is said to be valid if:

  1. All indices are valid.
  2. start <= stop, note that start = stop is permitted, in this case, this denotes an empty range.
  3. stop <= eos, where eos is the end-of-source position, also known as the source length, of source
type t

The abstract type of ranges.

include Ppx_compare_lib.Equal.S with type t := t
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Core.Comparable.S with type t := t
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix 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 compare : t -> t -> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
type comparator_witness
val validate_lbound : min:t Core.Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Core.Maybe_bound.t -> t Validate.check
val validate_bound : min:t Core.Maybe_bound.t -> max:t Core.Maybe_bound.t -> t Validate.check
include Core.Invariant.S with type t := t
val invariant : t -> unit
include Core.Pretty_printer.S with type t := t
val pp : Base.Formatter.t -> t -> unit
val create : source:Source.t -> int -> int -> t

create ~source start stop builds the range [start, stop) (not including the byte at the ending position) from the byte indices start and stop. A range is empty if its start and stop indices are the same.

  • parameter source

    the associated source of the range.

  • raises Invalid_argument

    if the start is greater than stop or stop is greater than the end-of-source position in source.

val initial : Source.t -> t

initial source is the initial range, namely [0, 0).

val eos : Source.t -> t

eos source is the end-of-source range [eos, eos) for the given source.

val source : t -> Source.t

source t returns the source associated with t.

val start : t -> int

start t returns the byte index of the (inclusive) start position.

val stop : t -> int

stop t returns the byte index of the (exclusive) stop position.

val split : t -> int * int

split t returns the pair of byte indices of t.

val merge : t -> t -> t

merge t1 t2 returns the merged interval [start, stop) where start = min start1 start2 and stop = max stop1 stop2.

  • raises Invalid_argument

    if the two ranges have differing sources. The comparison of sources is performed by Source.equal.

val inter : t -> t -> t

inter t1 t2 returns the intersectional interval [start, stop) where start = min start1 start2 and stop = max stop1 stop2.

  • raises Invalid_argument

    if the two ranges have differing sources. The comparison of sources is performed by Source.equal.

val are_disjoint : t -> t -> bool

are_disjoint t1 t2 returns whether the two ranges t1 and t2 are disjoint.

val contains : t -> int -> bool

contains t idx returns whether the position idx is within the range t.

Support for Lexing

val of_lex : ?source:Source.t -> (Lexing.position * Lexing.position) -> t

of_lex (start, stop) takes a pair of OCaml lexer positions and creates a range. It is equivalent to make ~source:default (Byte_index.of_lex start) (Byte_index.of_lex stop).

  • parameter source

    The source of the new range. The default source is `File start.pos_fname.

  • raises Invalid_argument

    if the optional argument source is not given and start.pos_fname and stop.pos_fname differ. The comparison is done by String.equal without any path canonicalization.

val of_lexbuf : ?source:Source.t -> Lexing.lexbuf -> t

of_lexbuf lexbuf constructs a range from the current lexeme that lexbuf points to. It is of_lex (Lexing.lexeme_start_p lexbuf, Lexing.lexeme_end_p lexbuf).

  • parameter source

    The source of the new range. The default source is `File (Lexing.lexeme_start_p lexbuf).pos_fname.

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