A typed regular expression.

The type variable is the type of the returned value when the typed regular expression (tyregex) is executed. tyregexs are bi-directional and can be used both for matching and evaluation. Multiple tyregexs can be combined in order to do routing in similar manner as switches/pattern matching.

Typed regular expressions are strictly as expressive as regular expressions from re (and are, as such, regular expressions, not PCREs). Performances should be exactly the same.

For example tyre : int t can be used to return an int. In the rest of the documentation, we will use tyre to designate a value of type t.

pcre s is a tyregex that matches the PCRE s and return the corresponding string. Groups in s are ignored.

regex re is a tyregex that matches re and return the corresponding string. Groups inside re are erased.

conv to_ from_ tyre matches the same text as tyre, but converts back and forth to a different data type.

to_ is allowed to raise an exception exn. In this case, exec will return `ConverterFailure exn.

For example, this is the implementation of pos_int:

let pos_int =
  Tyre.conv
    int_of_string string_of_int
    (Tyre.regex (Re.rep1 Re.digit))

opt tyre matches either tyre or the empty string. Similar to Re.opt.

alt tyreL tyreR matches either tyreL (and will then return `Left v) or tyreR (and will then return `Right v).

rep tyre matches tyre zero or more times. Similar to Re.rep.

For matching, rep tyre will matches the string a first time, then tyre will be used to walk the matched part to extract values.

rep1 tyre is seq tyre (rep tyre). Similar to Re.rep1.

seq tyre1 tyre2 matches tyre1 then tyre2 and return both values.

prefix tyre_i tyre matches tyre_i, ignores the result, and then matches tyre and returns its result. Converters in tyre_i are never called.

Same as prefix, but reversed.

t <|> t' is alt t t'.

t <&> t' is seq t t'.

ti *> t is prefix ti t.

t <* ti is suffix t ti.

str s matches s and evaluates to s.

char c matches c and evaluates to c.

blanks matches Re.(rep blank) and doesn't return anything.

int matches -?[0-9]+ and returns the matched integer.

Integers that do not fit in an int will fail.

pos_int matches [0-9]+ and returns the matched positive integer.

Integers that do not fit in an int will fail.

float matches -?[0-9]+( .[0-9]* )? and returns the matched floating point number.

Floating point numbers that do not fit in a float returns infinity or neg_infinity.

bool matches true|false and returns the matched boolean.

list e is similar to rep e, but returns a list.

terminated_list ~sep tyre is list (tyre <* sep) .

separated_list ~sep tyre is equivalent to opt (e <&> list (sep *> e)).

A compiled typed regular expression.

compile tyre is the compiled tyregex representing tyre.

exec ctyre s matches the string s using the compiled tyregex ctyre and returns the extracted value.

Returns Error (`NoMatch (tyre, s) if tyre doesn't match s. Returns Error (`ConverterFailure exn) if a converter failed with the exception exn.

• parameter pos

  optional beginning of the string (default 0)

• parameter len

  length of the substring of str that can be matched (default to the end of the string)

execp ctyre s returns true if ctyre matches s. Converters are never called.

• parameter pos

  optional beginning of the string (default 0)

• parameter len

  length of the substring of str that can be matched (default to the end of the string)

• since 0.1.1

all ctyre s calls to exec repeatedly and returns the list of all the matches.

all_seq ctyre s is all ctyre s but returns a gen instead. Matches are enumerated lazily.

Exceptions raised by converters are not caught.

tyre --> f is Route (tyre, f).

route [ tyre1 --> f1 ; tyre2 --> f2 ] produces a compiled tyregex such that, if tyre1 matches, f1 is called, and so on.

The compiled tyregex shoud be used with exec.

eval tyre v returns a string s such that exec (compile tyre) s = v.

Note that such string s is not unique. eval will usually returns a very simple witness.

evalpp tyre ppf v is equivalent to Format.fprintf ppf "%s" (eval tyre v), but more efficient.

Is is generally used with "%a":

let my_pp = Tyre.evalpp tyre in
Format.printf "%a@." my_pp v

Internal types