| (//~!) [Re2_internal_intf.S.Infix] | |
| (//~) [Re2_internal_intf.S.Infix] | input //~ pattern an infix alias of find_first *
|
| (=~) [Re2_internal_intf.S.Infix] | input =~ pattern an infix alias of matches
|
| (~/) [Re2_internal_intf.S.Infix] | create_exn
|
| __bin_read_t__ [Re2_internal_intf.S] | |
A | |
| alnum [Parser.Char] |
A character matching
Char.is_alphanum
|
| alpha [Parser.Char] |
A character matching
Char.is_alpha
|
| and_capture [Parser] | and_capture t returns the string matched by t in addition to whatever it was
already going to return.
|
| any [Parser.Char] | any, unlike "." by default, matches newline.
|
B | |
| bin_read_t [Re2_internal_intf.S] | |
| bin_reader_t [Re2_internal_intf.S] | |
| bin_size_t [Re2_internal_intf.S] | |
| bin_t [Re2_internal_intf.S] | |
| bin_write_t [Re2_internal_intf.S] | |
| bin_writer_t [Re2_internal_intf.S] | |
C | |
| capture [Parser] | capture t returns the string matched by t
|
| compare [Re2_internal_intf.S] | |
| compile [Parser] | case_sensitive defaults to true.
|
| create [Re2_internal_intf.S] | |
| create_exn [Re2_internal_intf.S] | |
D | |
| digit [Parser.Decimal] | |
| digit [Parser.Char] |
A character matching
Char.is_digit
|
E | |
| end_of_input [Parser] |
Matches empty string at the end of the text
|
| escape [Re2_internal_intf.S] | escape nonregex
|
F | |
| fail [Parser] |
Regex that matches nothing
|
| find_all [Re2_internal_intf.S] | find_all t input a convenience function that returns all non-overlapping
matches of t against input, in left-to-right order.
|
| find_all_exn [Re2_internal_intf.S] | |
| find_first [Re2_internal_intf.S] | 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.
|
| find_first_exn [Re2_internal_intf.S] | |
| find_submatches [Re2_internal_intf.S] | find_submatches t input finds the first match and returns all submatches.
|
| find_submatches_exn [Re2_internal_intf.S] | |
G | |
| get [Re2_internal_intf.S.Match] |
If location information has been omitted (e.g., via
~sub), the error returned is
Regex_no_such_subpattern, just as though that subpattern were never defined.
|
| get_all [Re2_internal_intf.S.Match] | get_all t returns all available matches as strings in an array.
|
| get_exn [Re2_internal_intf.S.Match] | |
| get_matches [Re2_internal_intf.S] | get_matches pattern input returns all non-overlapping matches of pattern
against input
|
| get_matches_exn [Re2_internal_intf.S] | |
| get_pos_exn [Re2_internal_intf.S.Match] | get_pos_exn ~sub t returns the start offset and length in bytes.
|
I | |
| ignore [Parser] | ignore t is a regex which matches the same strings that t matches, but doesn't
call functions on the captured submatches.
|
| index_of_id_exn [Re2_internal_intf.S] | index_of_id t id resolves subpattern names and indices into indices.
|
| int [Parser.Decimal] | |
L | |
| lower [Parser.Char] |
A character matching
Char.is_lowercase
|
M | |
| matches [Re2_internal_intf.S] | matches pattern input
|
| matches [Parser] | |
N | |
| not_one_of [Parser.Char] | |
| num_submatches [Re2_internal_intf.S] | num_submatches t returns 1 + the number of open-parens in the pattern.
|
O | |
| of_re2 [Parser] | of_re2 r forgets the options that r was compiled with, instead using
`Encoding_latin1 true, `Dot_nl true, and the case-sensitivity setting of the
overall pattern.
|
| one_of [Parser.Char] |
Duplicates in the lists given to
one_of and not_one_of are ignored.
|
| optional [Parser] | greedy defaults to true.
|
| or_ [Parser] | |
P | |
| pattern [Re2_internal_intf.S] | pattern t returns the pattern from which the regex was constructed.
|
R | |
| repeat [Parser] | repeat ~min ~max t constructs the regex t{min,max}.
|
| replace [Re2_internal_intf.S] | replace ?sub ?max ~f pattern input
|
| replace_exn [Re2_internal_intf.S] | |
| rewrite [Re2_internal_intf.S] | 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.
|
| rewrite_exn [Re2_internal_intf.S] | |
| run [Parser] | |
S | |
| sexp_of_t [Re2_internal_intf.S.Match] | |
| sexp_of_t [Re2_internal_intf.S] | |
| sexp_of_t [Parser] | |
| sign [Parser.Decimal] |
optional sign symbol:
"+" or "" mean 1
"-" means -1
|
| space [Parser.Char] |
A character matching
Char.is_whitespace
|
| split [Re2_internal_intf.S] | split pattern input
|
| start_of_input [Parser] |
Matches empty string at the beginning of the text
|
| string [Parser] | string, Char.one_of, and Char.not_one_of raise exceptions in the presence of
null bytes
|
T | |
| t_of_sexp [Re2_internal_intf.S] | |
| times [Parser] | times r n essentially constructs the regex r{n}.
|
| to_re2 [Parser] | |
| to_regex_string [Parser] | to_regex_string and to_re2 both forget what a 'a t knows
about turning the matching strings into 'as
|
U | |
| unsigned [Parser.Decimal] | |
| upper [Parser.Char] |
A character matching
Char.is_uppercase
|
V | |
| valid_rewrite_template [Re2_internal_intf.S] | valid_rewrite_template pattern ~template
|