| ( *> ) [Tyre.Infix] | ti *> t is prefix ti t.
|
| ( *> ) [Tyre] | ti *> t is prefix ti t.
|
| ( <* ) [Tyre.Infix] | t <* ti is suffix t ti.
|
| ( <* ) [Tyre] | t <* ti is suffix t ti.
|
| (-->) [Tyre] | tyre --> f is Route (tyre, f).
|
| (<&>) [Tyre.Infix] | t <&> t' is seq t t'.
|
| (<&>) [Tyre] | t <&> t' is seq t t'.
|
| (<|>) [Tyre.Infix] | t <|> t' is alt t t'.
|
| (<|>) [Tyre] | t <|> t' is alt t t'.
|
A | |
| all [Tyre] | all ctyre s calls to Tyre.exec repeatedly and returns the list of all the matches.
|
| all_gen [Tyre] | |
| alt [Tyre] | alt tyreL tyreR matches either tyreL (and will then return `Left v) or tyreR (and will then return `Right v).
|
B | |
| blanks [Tyre] | blanks matches Re.(rep blank) and doesn't return anything.
|
| bool [Tyre] | bool matches true|false and returns the matched boolean.
|
| build [Tyre.Internal] | |
C | |
| char [Tyre] | char c matches c and evaluates to c.
|
| compile [Tyre] | compile tyre is the compiled tyregex representing tyre.
|
| conv [Tyre] | conv to_ from_ tyre matches the same text as tyre, but converts back and forth to a different data type.
|
E | |
| eval [Tyre] | eval tyre v returns a string s such that exec (compile tyre) s = v.
|
| evalpp [Tyre] | evalpp tyre ppf v is equivalent to Format.fprintf ppf "%s" (eval tyre v), but more efficient.
|
| exec [Tyre] | exec ctyre s matches the string s using
the compiled tyregex ctyre and returns the extracted value.
|
| execp [Tyre] | execp ctyre s returns true if ctyre matches s.
|
| extract [Tyre.Internal] | |
F | |
| first [Tyre] | |
| float [Tyre] | float matches -?[0-9]+( .[0-9]* )? and returns the matched floating point number.
|
| from_t [Tyre.Internal] | |
G | |
| greedy [Tyre] | |
I | |
| int [Tyre] | int matches -?[0-9]+ and returns the matched integer.
|
L | |
| list [Tyre] | list e is similar to rep e, but returns a list.
|
| longest [Tyre] | |
N | |
| nest [Tyre] | |
| non_greedy [Tyre] | |
O | |
| opt [Tyre] | opt tyre matches either tyre or the empty string.
|
P | |
| pos_int [Tyre] | pos_int matches [0-9]+ and returns the matched positive integer.
|
| pp [Tyre] | |
| pp_error [Tyre] | |
| pp_re [Tyre] | |
| prefix [Tyre] | prefix tyre_i tyre matches tyre_i, ignores the result, and then matches tyre and returns its result.
|
R | |
| regex [Tyre] | regex re is a tyregex that matches re and return the corresponding string.
|
| rep [Tyre] | rep tyre matches tyre zero or more times.
|
| rep1 [Tyre] | rep1 tyre is seq tyre (rep tyre).
|
| route [Tyre] | route [ tyre1 --> f1 ; tyre2 --> f2 ] produces a compiled
tyregex such that, if tyre1 matches, f1 is called, and so on.
|
S | |
| separated_list [Tyre] | separated_list ~sep tyre is equivalent to opt (e <&> list (sep *> e)).
|
| seq [Tyre] | seq tyre1 tyre2 matches tyre1 then tyre2 and return both values.
|
| shortest [Tyre] | |
| start [Tyre] | |
| stop [Tyre] | |
| str [Tyre] | str s matches s and evaluates to s.
|
| suffix [Tyre] |
Same as
prefix, but reversed.
|
T | |
| terminated_list [Tyre] | terminated_list ~sep tyre is list (tyre <* sep) .
|
| to_t [Tyre.Internal] | |
W | |
| whole_string [Tyre] | |
| word [Tyre] |