# Module Cf_regex

    module Cf_regex: sig .. end

Regular expression parsing, search and matching.

###### Overview

This module implements regular expression parsing, search and matching in pure Objective Caml. The grammar for regular expressions is a little unconventional. Instead of using a backslash as the escape character, the backtick character is used instead. This makes it easy to write regular expressions in string literals.

Use any of the following constructions in regular expressions:

- ``n` Matches LF ("newline") character.
- ``t` Matches TAB character.
- ``r` Matches RETURN character.
- ``a` Matches an alphabetical character.
- ``d` Matches a decimal digit character.
- ``i` Matches an alphanumerical character.
- ``s` Matches a TAB, LF, VT, FF, CR or SPACE (whitespace) character.
- ``w` Matches a character other than a whitespace character.
- ``xNN` Matches the character with hexadecimal code `NN`.
- ``DDD` Matches the character with decimal code `DDD`, where DDD is a three digit number between `000` and `255`.
- ``c_` Matches the control character corresponding to the subsequent printable character, e.g. ``cA` is CONTROL-A, and ``c[` is ESCAPE.
- `.` Matches any character except newline.
- `*` (postfix) Matches the preceding expression, zero, one or several times in sequence.
- `+` (postfix) Matches the preceding expression, one or several times in sequence.
- `?` (postfix) Matches the preceding expression once or not at all.
- `[..]` Character set. Ranges are denoted with `'-'`, as in `[a-z]`. An initial `'^'`, as in `[^0-9]`, complements the set. Special characters in the character set syntax may be included in the set by escaping them with a backtick, e.g. `[`^```]]` is a set containing three characters: the carat, the backtick and the right bracket characters.
- `(..|..)` Alternatives. Matches one of the expressions between the parentheses, which are separated by vertical bar characters.
- ``_` Escaped special character. The special characters are `'`'`, `'.'`, `'*'`, `'+'`, `'?'`, `'('`, `'|'`, `')'`, `'['`.

###### Modules

    module DFA: Cf_dfa.T  with type S.t = char

The deterministic finite automata on octet character symbols.

###### Exceptions

    exception Error of string

An error parsing the specified string as a regular expression.

###### Types

    type t

An abstract type representing a regular expression.

###### Functions

    val expr_parse : (char, DFA.x) Cf_parser.t

A parser combinator on character streams that recognizes a regular expression and produces a DFA expression for it.

    val expr_of_seq : char Cf_seq.t -> DFA.x

Use `expr_of_seq z` to evaluate the character sequence `z` as a regular expression and produce the corresponding DFA expression. Raises `Error` if the sequence is not a valid expression.

    val expr_of_string : string -> DFA.x

Use `expr_of_string s` to evaluate the string `s` as a regular expression and produce the corresponding DFA expression. Raises `Error` if the string is not a valid expression.

    val quote : (char, char) Cf_flow.t

A character flow that quotes all the special characters in the input so that the output may be used in a regular expression to match the input exactly.

    val unquote : (char, char) Cf_flow.t

A character flow that unquotes all the quoted special characters in the input so that the output may by used in a regular expression to match the specified pattern.

    val of_expression : DFA.x -> t

Use `of_expression x` to produce a regular expression from the DFA expression `x`.

    val of_seq : char Cf_seq.t -> t

Use `of_seq z` to ingest the whole character sequence `z`, parse it and produce a regular expression. Raises `Error s` if the sequence is not a valid regular expression, with `s` containing the string composed of the characters in the sequence.

    val of_string : string -> t

Use `of_string s` to produce a regular expression from the string `s`. Raises `Error s` if the string is not a valid regular expression.

    val test : t -> string -> bool

Use `test r s` to test whether the string `s` matches the regular expression `r`.

    val search : t -> char Cf_seq.t -> int * int

Use `search r z` to search the character sequence `z` for a pattern that matches the regular expression `r`. Returns `(pos, len)`, where `pos` is the number of characters into the sequence where the matching sequence begins, and `len` is the number matching characters.

    val separate : t -> char Cf_seq.t -> char Cf_seq.t Cf_seq.t

Use `separate r z` to map the character sequence `z` into the sequence of sequences found between matches for the regular expression `r`.

    val split : t -> string -> string list

Use `split r s` to produce a list of strings by searching `s` left to right for blocks of characters between patterns that match the regular expression `r`.

    val parse : t -> (char, string) Cf_parser.t

Use `parse r` to produce a parser that matches the input stream to the regular expression `r` and returns the corresponding string value.

    val parsex : t -> ('a #Cf_parser.cursor, char, string) Cf_parser.X.t

Use `parse r` to produce a parser that matches the input stream to the regular expression `r` and returns the corresponding string value.