Re, they have a different type from regex.(evaluable, 'a) Tyre.t and (non_evaluable, 'a) Tyre.t.type pattern for (non_evaluable, 'a) Tyre.t.val lift : ('a -> string) -> 'a pattern -> ('e, 'a) t to transform a pattern into an expression by giving an explicit conversion function. Also liftpp that does the same with better performance by using Format.val unlift : (evaluable, 'a) t -> 'a pattern.val either: ('e, 'a) Tyre.t -> ('e, 'b) Tyre.t -> ('e, ('a, 'b) Either.t) Tyre.t.alt to (_, 'a) t -> (_, 'a) t -> 'a pattern. Previous users of alt should switch to either.val alt_eval: ('a -> [`Left | `Right]) -> ('e, 'a) t -> ('e, 'a) t -> ('e, 'a) t This has flat typing but is compatible with eval.<|> is alt, <||> is either.val map : ('a -> 'b) -> (_, 'a) t -> 'b pattern and its corresponding operators: let+ and <$>.(and+) which is an alias of seq.val app: ('e, 'a -> 'b) t -> ('e, 'a) t -> 'b pattern and its corresponding operator <*>val matched_string : (_, 'a) t -> (_, string) t that discards the computed value and just return the string that was matched.Result library. Stdlib is now used.val rep_charset: Charset.t -> (_, string) t, and shortcut val rep_any: (_, string) t.<?> to <|><*> to <&>str and char combinators for constant patterns.blank combinator.Tyre.conv is now separated into two combinators, conv which doesn't use an option, but is not allowed to fail, and conv_fail which allows failures.<*) and suffix (*>) operators now accepts tyregexs on both sides. The old behavior can be recovered by combining with Tyre.str. This makes prefixstr/suffixstr (**>/<**) redundant, they are removed.Tyre.str.start and stop combinators.Tyre.whole_string or Tyre.start and Tyre.stop instead.First version :tada: