package re_parser

You can search for identifiers within the package.

in-package search v0.2.0

re_parser
- Re_parser
  - Applicative_infix
  - Char
  - Decimal
  - Let_syntax
    
    Let_syntax
  - Open_on_rhs_intf
    
    S
    
    Applicative_infix
    
    Char
    
    Decimal

Legend:
Library
Module
Module type
Parameter
Class
Class type

type 'a t

module Open_on_rhs_intf : sig ... end

include Base.Applicative.Let_syntax
  with type 'a t := 'a t
  with module Open_on_rhs_intf := Open_on_rhs_intf

module Let_syntax : sig ... end

include Open_on_rhs_intf.S with type 'a t := 'a t

include Regex_parser_intf.S with type 'a t := 'a t

val compile : 
  ?case_sensitive:Base.bool ->
  'a t ->
  (Base.string -> 'a Base.option) Base.Staged.t

case_sensitive defaults to true.

val run : ?case_sensitive:Base.bool -> 'a t -> Base.string -> 'a Base.option

val matches : ?case_sensitive:Base.bool -> 'a t -> Base.string -> Base.bool

The applicative interface provides sequencing, e.g. both a b is a regex that parses an a followed by a b and returns both results in a pair.

include Base.Applicative.S with type 'a t := 'a t

val return : 'a -> 'a t

val map : 'a t -> f:('a -> 'b) -> 'b t

val both : 'a t -> 'b t -> ('a * 'b) t

val (<*>) : ('a -> 'b) t -> 'a t -> 'b t

same as apply

val (<*) : 'a t -> unit t -> 'a t

val (*>) : unit t -> 'a t -> 'a t

val (>>|) : 'a t -> ('a -> 'b) -> 'b t

val apply : ('a -> 'b) t -> 'a t -> 'b t

val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t

val map3 : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t

val all : 'a t list -> 'a list t

val all_unit : unit t list -> unit t

module Applicative_infix : sig ... end

val ignore_m : _ t -> Base.unit t

ignore_m t is a regex which matches the same strings that t matches, but doesn't call functions on the captured submatches. Particularly, something like ignore (map (string "x") ~f:Int.of_string) won't raise an exception, because the int conversion is never attempted.

val capture : Base.unit t -> Base.string t

capture t returns the string matched by t

val and_capture : 'a t -> ('a * Base.string) t

and_capture t returns the string matched by t in addition to whatever it was already going to return.

val fail : 'a t

Regex that matches nothing

val or_ : 'a t Base.list -> 'a t

val optional : ?greedy:Base.bool -> 'a t -> 'a Base.option t

greedy defaults to true. If false, the regexp will prefer not matching.

val repeat : 
  ?greedy:Base.bool ->
  ?min:Base.int ->
  ?max:Base.int Base.option ->
  Base.unit t ->
  Base.unit t

repeat ~min ~max t constructs the regex t{min,max}. min defaults to 0 and max defaults to None (unbounded), so that just plain repeat t is equivalent to t*.

It would be better for repeat to be 'a t -> 'a list t, but the Re2 library, for example, doesn't give you access to repeated submatches like that. Hence, repeat ignores all submatches of its argument and does not call any callbacks that may have been attached to them, as if it had ignore called on its result.

val times : Base.unit t -> Base.int -> Base.unit t

times r n essentially constructs the regex r{n}. It is equivalent to repeat ~min:n ~max:(Some n) r.

Compare with, say, all (List.init n ~f:(fun _ -> r)), which constructs the regex rrr...r (with n copies of r) and has the type 'a t -> 'a list t.

val string : Base.string -> Base.unit t

val any_string : Base.string t

val start_of_input : Base.unit t

Matches empty string at the beginning of the text

val end_of_input : Base.unit t

Matches empty string at the end of the text

module Char : sig ... end

module Decimal : sig ... end

val to_re : ?case_sensitive:Base.bool -> _ t -> Re.t

val of_re : Re.t -> Base.unit t