Module ReSource

Regular expression

Compiled regular expression

Manipulate matching groups.

• deprecated Use Group.t

Compile a regular expression into an executable version that can be used to match strings, e.g. with exec.

Return the number of capture groups (including the one corresponding to the entire regexp).

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.Group.t = <abstr>

  # Re.exec regex "# a C comment?";;
  Exception: Not_found

  # Re.exec ~pos:1 regex "// a C comment";;
  Exception: Not_found

• parameter pos

  optional beginning of the string (default 0)

• parameter len

  length of the substring of str that can be matched (default -1, meaning to the end of the string)

• raises Not_found

  if the regular expression can't be found in str

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.Group.t option = Some <abstr>

  # Re.exec_opt regex "# a C comment?";;
  - : Re.Group.t option = None

  # Re.exec_opt ~pos:1 regex "// a C comment";;
  - : Re.Group.t option = None

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

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

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.

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.Group.t list = [<abstr>; <abstr>; <abstr>; <abstr>]

  # Re.all regex "My head, My shoulders, My knees, My toes ...";;
  - : Re.Group.t list = []

• deprecated

  Use Seq.all instead.

• deprecated

  Use Seq.all instead.

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"]

• deprecated

  Use Seq.matches instead.

• deprecated

  Use Seq.matches instead.

split re s splits s into chunks separated by re. It yields the chunks themselves, not the separator. An occurence of the separator at the beginning or the end of the string is ignoring.

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 regex ",1,2,";;
  - : string list = ["1"; "2"]

  # Re.split ~pos:3 regex "1,2,3,4. Commas go brrr.";;
  - : string list = ["3"; "4. Commas go brrr."]

Zero-length patterns:

Be careful when using split with zero-length patterns like eol, bow, and eow. Because they don't have any width, they will still be present in the result. (Note the position of the \n and space characters in the output.)

  # Re.split (Re.compile Re.eol) "a\nb";;
  - : string list = ["a"; "\nb"]

  # Re.split (Re.compile Re.bow) "a b";;
  - : string list = ["a "; "b"]

  # Re.split (Re.compile Re.eow) "a b";;
  - : string list = ["a"; " b"]

Compare this to the behavior of splitting on the char itself. (Note that the delimiters are not present in the output.)

  # Re.split (Re.compile (Re.char '\n')) "a\nb";;
  - : string list = ["a"; "b"]

  # Re.split (Re.compile (Re.char ' ')) "a b";;
  - : string list = ["a"; "b"]

split_delim re s splits s into chunks separated by re. It yields the chunks themselves, not the separator. Occurences of the separator at the beginning or the end of the string will produce empty chunks.

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 regex ",1,2,";;
  - : string list = [""; "1"; "2"; ""]

  # Re.split ~pos:3 regex "1,2,3,4. Commas go brrr.";;
  - : string list = ["3"; "4. Commas go brrr."]

Zero-length patterns:

Be careful when using split_delim with zero-length patterns like eol, bow, and eow. Because they don't have any width, they will still be present in the result. (Note the position of the \n and space characters in the output.)

  # Re.split_delim (Re.compile Re.eol) "a\nb";;
  - : string list = ["a"; "\nb"; ""]

  # Re.split_delim (Re.compile Re.bow) "a b";;
  - : string list = [""; "a "; "b"]

  # Re.split_delim (Re.compile Re.eow) "a b";;
  - : string list = ["a"; " b"; ""]

Compare this to the behavior of splitting on the char itself. (Note that the delimiters are not present in the output.)

  # Re.split_delim (Re.compile (Re.char '\n')) "a\nb";;
  - : string list = ["a"; "b"]

  # Re.split_delim (Re.compile (Re.char ' ')) "a b";;
  - : string list = ["a"; "b"]

• deprecated

  Use Seq.split instead.

• deprecated

  Use Seq.split instead.

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."]

• deprecated

  Use Seq.split_full instead.

• deprecated

  Use Seq.split_full instead.

Alternative.

alt [] is equivalent to empty.

By default, the leftmost match is preferred (see match semantics below).

Sequence

Match nothing

Empty word

0 or more matches

1 or more matches

repn re i j matches re at least i times and at most j times, bounds included. j = None means no upper bound.

0 or 1 matches

Beginning of line

End of line

Beginning of word

End of word

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)

End of string. This is different from stop in the way described in bos.

Last end of line or end of string

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

Final position. This is different from eos in the way described in start.

Word

Not at a word boundary

Only matches the whole string, i.e. fun t -> seq [ bos; t; eos ].

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.

Same as longest, but matching the least number of bytes.

First match semantics for alternations (not repetitions). That is, matches will prefer the leftmost branch of the alternation that matches the text.

Greedy matches for repetitions (opt, rep, rep1, repn): they will match as many times as possible.

Non-greedy matches for repetitions (opt, rep, rep1, repn): they will match as few times as possible.

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.

Remove all groups

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.

Any character of the string

Character ranges

Intersection of character sets

Difference of character sets

Complement of union

Any character

Any character but a newline

Case sensitive matching. Note that this works on latin1, not ascii and not utf8.

Case insensitive matching. Note that this works on latin1, not ascii and not utf8.

Alias for pp_re. Deprecated

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.

Alias for Group.t. Deprecated

• deprecated Use Group.t

Same as Group.get. Deprecated

• deprecated Use Group.get

Same as Group.offset. Deprecated

• deprecated Use Group.offset

Same as Group.all. Deprecated

• deprecated Use Group.all

Same as Group.all_offset. Deprecated

• deprecated Use Group.all_offset

Same as Group.test. Deprecated

• deprecated Use Group.test

Alias for Mark.t. Deprecated

• deprecated Use Mark.

Same as Mark.test. Deprecated

• deprecated Use Mark.test

Same as Mark.all. Deprecated

• deprecated Use Mark.all

An experimental for matching a regular expression by feeding individual string chunks.

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.

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]"

A view of the top-level of a regex. This type is unstable and may change

Emacs-style regular expressions

Shell-style regular expressions

Perl-style regular expressions

NOTE: Only a subset of the PCRE spec is supported

References:

Module Str: regular expressions and high-level string processing