Module Re2.Regex

include Re2__.Regex_intf.S
Basic Types
type t
include Bin_prot.Binable.S with type t := t
type t
include Bin_prot.Binable.S_only_functions with type t := t
type t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
val compare : t -> t -> int
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
type t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
type regex = t
type id_t = [
| `Index of int
| `Name of string
]

Subpatterns are referenced by name if labelled with the /(?P<...>...)/ syntax, or else by counting open-parens, with subpattern zero referring to the whole regex.

val index_of_id_exn : t -> id_t -> int

index_of_id t id resolves subpattern names and indices into indices. *

module Options = Options
val create : ?⁠options:Options.t -> string -> t Core_kernel.Or_error.t
val create_exn : ?⁠options:Options.t -> string -> t
include Core_kernel.Stringable with type t := t
type t
val of_string : string -> t
val to_string : t -> string
val num_submatches : t -> int

num_submatches t returns 1 + the number of open-parens in the pattern.

N.B. num_submatches t == 1 + RE2::NumberOfCapturingGroups() because RE2::NumberOfCapturingGroups() ignores the whole match ("subpattern zero").

val pattern : t -> string

pattern t returns the pattern from which the regex was constructed.

val options : t -> Options.t
val find_all : ?⁠sub:id_t -> t -> string -> string list Core_kernel.Or_error.t

find_all t input a convenience function that returns all non-overlapping matches of t against input, in left-to-right order.

If sub is given, and the requested subpattern did not capture, then no match is returned at that position even if other parts of the regex did match.

val find_all_exn : ?⁠sub:id_t -> t -> string -> string list
val find_first : ?⁠sub:id_t -> t -> string -> string Core_kernel.Or_error.t

find_first ?sub pattern input finds the first match of pattern in input, and returns the subpattern specified by sub, or an error if the subpattern didn't capture.

val find_first_exn : ?⁠sub:id_t -> t -> string -> string
val find_submatches : t -> string -> string option array Core_kernel.Or_error.t

find_submatches t input finds the first match and returns all submatches. Element 0 is the whole match and element 1 is the first parenthesized submatch, etc.

val find_submatches_exn : t -> string -> string option array
val matches : t -> string -> bool

matches pattern input

returns

true iff pattern matches input

val split : ?⁠max:int -> ?⁠include_matches:bool -> t -> string -> string list

split pattern input

returns

input broken into pieces where pattern matches. Subpatterns are ignored.

parameter max

(default: unlimited) split only at the leftmost max matches

parameter include_matches

(default: false) include the matched substrings in the returned list (e.g., the regex /[,()]/ on "foo(bar,baz)" gives ["foo"; "("; "bar"; ","; "baz"; ")"] instead of ["foo"; "bar"; "baz"])

If t never matches, the returned list has input as its one element.

val rewrite : t -> template:string -> string -> string Core_kernel.Or_error.t

rewrite pattern ~template input is a convenience function for replace: Instead of requiring an arbitrary transformation as a function, it accepts a template string with zero or more substrings of the form "\\n", each of which will be replaced by submatch n. For every match of pattern against input, the template will be specialized and then substituted for the matched substring.

val rewrite_exn : t -> template:string -> string -> string
val valid_rewrite_template : t -> template:string -> bool

valid_rewrite_template pattern ~template returns true iff template is a valid rewrite template for pattern

val escape : string -> string

escape nonregex returns a copy of nonregex with everything escaped (i.e., if the return value were t to regex, it would match exactly the original input)

Infix Operators
module Infix : sig ... end
Complicated Interface
type 'a without_trailing_none
val sexp_of_without_trailing_none : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a without_trailing_none -> Ppx_sexp_conv_lib.Sexp.t
val without_trailing_none : 'a -> 'a without_trailing_none

This type marks call sites affected by a bugfix that eliminated a trailing None. When you add this wrapper, check that your call site does not still work around the bug by dropping the last element.

module Match : sig ... end
val get_matches : ?⁠sub:id_t -> ?⁠max:int -> t -> string -> Match.t list Core_kernel.Or_error.t

get_matches pattern input returns all non-overlapping matches of pattern against input

parameter max

(default: unlimited) return only the leftmost max matches

parameter sub

(default: all) returned Match.t's will contain only the first sub matches.

val get_matches_exn : ?⁠sub:id_t -> ?⁠max:int -> t -> string -> Match.t list
val to_sequence_exn : ?⁠sub:id_t -> t -> string -> Match.t Core_kernel.Sequence.t
val first_match : t -> string -> Match.t Core_kernel.Or_error.t

first_match pattern input

returns

the first match iff pattern matches input

val first_match_exn : t -> string -> Match.t
val replace : ?⁠sub:id_t -> ?⁠only:int -> f:(Match.t -> string) -> t -> string -> string Core_kernel.Or_error.t

replace ?sub ?max ~f pattern input

returns

an edited copy of input with every substring matched by pattern transformed by f.

parameter only

(default: all) replace only the nth match

val replace_exn : ?⁠sub:id_t -> ?⁠only:int -> f:(Match.t -> string) -> t -> string -> string
module Exceptions : sig ... end
module Multiple : sig ... end