Re
module Group : sig ... end
Manipulate matching groups.
type groups = Group.t
Compile a regular expression into an executable version that can be used to match strings, e.g. with exec
.
val group_count : re -> int
Return the number of capture groups (including the one corresponding to the entire regexp).
val group_names : re -> (string * int) list
Return named capture groups with their index.
exec re str
searches str
for a match of the compiled expression re
, and returns the matched groups if any.
More specifically, when a match exists, exec
returns a match that starts at the earliest position possible. If multiple such matches are possible, the one specified by the match semantics described below is returned.
Examples:
# let regex = Re.compile Re.(seq [str "//"; rep print ]);;
val regex : re = <abstr>
# Re.exec regex "// a C comment";;
- : Re.substrings = <abstr>
# Re.exec regex "# a C comment?";;
Exception: Not_found
# Re.exec ~pos:1 regex "// a C comment";;
Exception: Not_found
Similar to exec
, but returns an option instead of using an exception.
Examples:
# let regex = Re.compile Re.(seq [str "//"; rep print ]);;
val regex : re = <abstr>
# Re.exec_opt regex "// a C comment";;
- : Re.substrings option = Some <abstr>
# Re.exec_opt regex "# a C comment?";;
- : Re.substrings option = None
# Re.exec_opt ~pos:1 regex "// a C comment";;
- : Re.substrings option = None
val execp : ?pos:int -> ?len:int -> re -> string -> bool
Similar to exec
, but returns true
if the expression matches, and false
if it doesn't. This function is more efficient than calling exec
or exec_opt
and ignoring the returned group.
Examples:
# let regex = Re.compile Re.(seq [str "//"; rep print ]);;
val regex : re = <abstr>
# Re.execp regex "// a C comment";;
- : bool = true
# Re.execp ~pos:1 regex "// a C comment";;
- : bool = false
val exec_partial :
?pos:int ->
?len:int ->
re ->
string ->
[ `Full | `Partial | `Mismatch ]
More detailed version of execp
. `Full
is equivalent to true
, while `Mismatch
and `Partial
are equivalent to false
, but `Partial
indicates the input string could be extended to create a match.
Examples:
# let regex = Re.compile Re.(seq [bos; str "// a C comment"]);;
val regex : re = <abstr>
# Re.exec_partial regex "// a C comment here.";;
- : [ `Full | `Mismatch | `Partial ] = `Full
# Re.exec_partial regex "// a C comment";;
- : [ `Full | `Mismatch | `Partial ] = `Partial
# Re.exec_partial regex "//";;
- : [ `Full | `Mismatch | `Partial ] = `Partial
# Re.exec_partial regex "# a C comment?";;
- : [ `Full | `Mismatch | `Partial ] = `Mismatch
val exec_partial_detailed :
?pos:int ->
?len:int ->
re ->
string ->
[ `Full of Group.t | `Partial of int | `Mismatch ]
More detailed version of exec_opt
. `Full group
is equivalent to Some group
, while `Mismatch
and `Partial _
are equivalent to None
, but `Partial position
indicates that the input string could be extended to create a match, and no match could start in the input string before the given position. This could be used to not have to search the entirety of the input if more becomes available, and use the given position as the ?pos
argument.
module Mark : sig ... end
Marks
Repeatedly calls exec
on the given string, starting at given position and length.
Examples:
# let regex = Re.compile Re.(seq [str "my"; blank; word(rep alpha)]);;
val regex : re = <abstr>
# Re.all regex "my head, my shoulders, my knees, my toes ...";;
- : Re.substrings list = [<abstr>; <abstr>; <abstr>; <abstr>]
# Re.all regex "My head, My shoulders, My knees, My toes ...";;
- : Re.substrings list = []
val matches : ?pos:int -> ?len:int -> re -> string -> string list
Same as all
, but extracts the matched substring rather than returning the whole group. This basically iterates over matched strings.
Examples:
# let regex = Re.compile Re.(seq [str "my"; blank; word(rep alpha)]);;
val regex : re = <abstr>
# Re.matches regex "my head, my shoulders, my knees, my toes ...";;
- : string list = ["my head"; "my shoulders"; "my knees"; "my toes"]
# Re.matches regex "My head, My shoulders, My knees, My toes ...";;
- : string list = []
# Re.matches regex "my my my my head my 1 toe my ...";;
- : string list = ["my my"; "my my"]
# Re.matches ~pos:2 regex "my my my my head my +1 toe my ...";;
- : string list = ["my my"; "my head"]
val split : ?pos:int -> ?len:int -> re -> string -> string list
split re s
splits s
into chunks separated by re
. It yields the chunks themselves, not the separator.
Examples:
# let regex = Re.compile (Re.char ',');;
val regex : re = <abstr>
# Re.split regex "Re,Ocaml,Jerome Vouillon";;
- : string list = ["Re"; "Ocaml"; "Jerome Vouillon"]
# Re.split regex "No commas in this sentence.";;
- : string list = ["No commas in this sentence."]
# Re.split ~pos:3 regex "1,2,3,4. Commas go brrr.";;
- : string list = ["3"; "4. Commas go brrr."]
val split_full : ?pos:int -> ?len:int -> re -> string -> split_token list
split re s
splits s
into chunks separated by re
. It yields the chunks along with the separators. For instance this can be used with a whitespace-matching re such as "[\t ]+"
.
Examples:
# let regex = Re.compile (Re.char ',');;
val regex : re = <abstr>
# Re.split_full regex "Re,Ocaml,Jerome Vouillon";;
- : Re.split_token list =
[`Text "Re"; `Delim <abstr>; `Text "Ocaml"; `Delim <abstr>;
`Text "Jerome Vouillon"]
# Re.split_full regex "No commas in this sentence.";;
- : Re.split_token list = [`Text "No commas in this sentence."]
# Re.split_full ~pos:3 regex "1,2,3,4. Commas go brrr.";;
- : Re.split_token list =
[`Delim <abstr>; `Text "3"; `Delim <abstr>; `Text "4. Commas go brrr."]
val split_full_gen : ?pos:int -> ?len:int -> re -> string -> split_token gen
val split_full_seq : ?pos:int -> ?len:int -> re -> string -> split_token Seq.t
module Seq : sig ... end
replace ~all re ~f s
iterates on s
, and replaces every occurrence of re
with f substring
where substring
is the current match. If all = false
, then only the first occurrence of re
is replaced.
val replace_string :
?pos:int ->
?len:int ->
?all:bool ->
re ->
by:string ->
string ->
string
replace_string ~all re ~by s
iterates on s
, and replaces every occurrence of re
with by
. If all = false
, then only the first occurrence of re
is replaced.
Examples:
# let regex = Re.compile (Re.char ',');;
val regex : re = <abstr>
# Re.replace_string regex ~by:";" "[1,2,3,4,5,6,7]";;
- : string = "[1;2;3;4;5;6;7]"
# Re.replace_string regex ~all:false ~by:";" "[1,2,3,4,5,6,7]";;
- : string = "[1;2,3,4,5,6,7]"
val str : string -> t
val char : char -> t
Alternative.
alt []
is equivalent to empty
.
By default, the leftmost match is preferred (see match semantics below).
val empty : t
Match nothing
val epsilon : t
Empty word
repn re i j
matches re
at least i
times and at most j
times, bounds included. j = None
means no upper bound.
We define a word as a sequence of latin1 letters, digits and underscore.
val bol : t
Beginning of line
val eol : t
End of line
val bow : t
Beginning of word
val eow : t
End of word
val bos : t
Beginning of string. This differs from start
because it matches the beginning of the input string even when using ~pos
arguments:
let b = execp (compile (seq [ bos; str "a" ])) "aa" ~pos:1 in
assert (not b)
val leol : t
Last end of line or end of string
val start : t
Initial position. This differs from bos
because it takes into account the ~pos
arguments:
let b = execp (compile (seq [ start; str "a" ])) "aa" ~pos:1 in
assert b
val not_boundary : t
Not at a word boundary
A regular expression frequently matches a string in multiple ways. For instance exec (compile (opt (str "a"))) "ab"
can match "" or "a". Match semantic can be modified with the functions below, allowing one to choose which of these is preferable.
By default, the leftmost branch of alternations is preferred, and repetitions are greedy.
Note that the existence of matches cannot be changed by specifying match semantics. seq [ bos; str "a"; non_greedy (opt (str "b")); eos ]
will match when applied to "ab". However if seq [ bos; str "a"; non_greedy (opt
(str "b")) ]
is applied to "ab", it will match "a" rather than "ab".
Also note that multiple match semantics can conflict. In this case, the one executed earlier takes precedence. For instance, any match of shortest (seq
[ bos; group (rep (str "a")); group (rep (str "a")); eos ])
will always have an empty first group. Conversely, if we use longest
instead of shortest
, the second group will always be empty.
Longest match semantics. That is, matches will match as many bytes as possible. If multiple choices match the maximum amount of bytes, the one respecting the inner match semantics is preferred.
First match semantics for alternations (not repetitions). That is, matches will prefer the leftmost branch of the alternation that matches the text.
Delimit a group. The group is considered as matching if it is used at least once (it may be used multiple times if is nested inside rep
for instance). If it is used multiple times, the last match is what gets captured.
When matching against nest e
, only the group matching in the last match of e will be considered as matching.
For instance:
let re = compile (rep1 (nest (alt [ group (str "a"); str "b" ]))) in
let group = Re.exec re "ab" in
assert (Group.get_opt group 1 = None);
(* same thing but without [nest] *)
let re = compile (rep1 (alt [ group (str "a"); str "b" ])) in
let group = Re.exec re "ab" in
assert (Group.get_opt group 1 = Some "a");
Mark a regexp. the markid can then be used to know if this regexp was used.
val set : string -> t
Any character of the string
val rg : char -> char -> t
Character ranges
val any : t
Any character
val notnl : t
Any character but a newline
val alnum : t
val wordc : t
val alpha : t
val ascii : t
val blank : t
val cntrl : t
val digit : t
val graph : t
val lower : t
val print : t
val punct : t
val space : t
val upper : t
val xdigit : t
Case insensitive matching. Note that this works on latin1, not ascii and not utf8.
val pp : Format.formatter -> t -> unit
val pp_re : Format.formatter -> re -> unit
val print_re : Format.formatter -> re -> unit
Alias for pp_re
. Deprecated
module View : sig ... end
val witness : t -> string
witness r
generates a string s
such that execp (compile r) s
is true.
Be warned that this function is buggy because it ignores zero-width assertions like beginning of words. As a result it can generate incorrect results.
val get_ofs : Group.t -> int -> int * int
Same as Group.offset
. Deprecated
val get_all_ofs : Group.t -> (int * int) array
Same as Group.all_offset
. Deprecated
val test : Group.t -> int -> bool
Same as Group.test
. Deprecated
val mark_set : Group.t -> Mark.Set.t
Same as Mark.all
. Deprecated
module Emacs : sig ... end
Emacs-style regular expressions
module Glob : sig ... end
Shell-style regular expressions
module Perl : sig ... end
Perl-style regular expressions
module Pcre : sig ... end
module Posix : sig ... end
References:
module Str : sig ... end
Module Str
: regular expressions and high-level string processing