module Re:sig
..end
Module Re
: regular expressions commons
type
t
Regular expression
type
re
Compiled regular expression
type
groups
Information about groups in a match.
val compile : t -> re
Compile a regular expression into an executable version that can be
used to match strings, e.g. with Re.exec
.
val exec : ?pos:int -> ?len:int -> re -> string -> groups
exec re str
matches str
against the compiled expression re
,
and returns the matched groups if any.
Not_found
if the regular expression can't be found in str
pos
: optional beginning of the string (default 0)len
: length of the substring of str
that can be matched (default -1
,
meaning to the end of the stringval exec_opt : ?pos:int -> ?len:int -> re -> string -> groups option
Similar to Re.exec
, but returns an option instead of using an exception.
val execp : ?pos:int -> ?len:int -> re -> string -> bool
Similar to Re.exec
, but returns true
if the expression matches,
and false
if it doesn't
val exec_partial : ?pos:int -> ?len:int -> re -> string -> [ `Full | `Mismatch | `Partial ]
More detailed version of exec_p
module Group:sig
..end
Manipulate matching groups.
module Mark:sig
..end
Marks
type'a
gen =unit -> 'a option
val all : ?pos:int -> ?len:int -> re -> string -> Group.t list
Repeatedly calls Re.exec
on the given string, starting at given
position and length.
val all_gen : ?pos:int -> ?len:int -> re -> string -> Group.t gen
Same as Re.all
but returns a generator
val matches : ?pos:int -> ?len:int -> re -> string -> string list
Same as Re.all
, but extracts the matched substring rather than
returning the whole group. This basically iterates over matched
strings
val matches_gen : ?pos:int -> ?len:int -> re -> string -> string gen
Same as Re.matches
, but returns a generator.
val split : ?pos:int -> ?len:int -> re -> string -> string list
split re s
splits s
into chunks separated by re
. It yields
the chunks themselves, not the separator. For instance
this can be used with a whitespace-matching re such as "[\t ]+"
.
val split_gen : ?pos:int -> ?len:int -> re -> string -> string gen
typesplit_token =
[ `Delim of Group.t | `Text of string ]
val split_full : ?pos:int -> ?len:int -> re -> string -> split_token list
val split_full_gen : ?pos:int -> ?len:int -> re -> string -> split_token gen
val replace : ?pos:int ->
?len:int ->
?all:bool -> re -> f:(Group.t -> string) -> string -> string
replace ~all re ~f s
iterates on s
, and replaces every occurrence
of re
with f substring
where substring
is the current match.
If all = false
, then only the first occurrence of re
is replaced.
val replace_string : ?pos:int -> ?len:int -> ?all:bool -> re -> by:string -> string -> string
replace_string ~all re ~by s
iterates on s
, and replaces every
occurrence of re
with by
. If all = false
, then only the first
occurrence of re
is replaced.
val str : string -> t
val char : char -> t
val alt : t list -> t
Alternative
val seq : t list -> t
Sequence
val empty : t
Match nothing
val epsilon : t
Empty word
val rep : t -> t
0 or more matches
val rep1 : t -> t
1 or more matches
val repn : t -> int -> int option -> t
repn re i j
matches re
at least i
times
and at most j
times, bounds included.
j = None
means no upper bound.
val opt : t -> t
0 or 1 matches
val bol : t
Beginning of line
val eol : t
End of line
val bow : t
Beginning of word
val eow : t
End of word
val bos : t
Beginning of string
val eos : t
End of string
val leol : t
Last end of line or end of string
val start : t
Initial position
val stop : t
Final position
val word : t -> t
Word
val not_boundary : t
Not at a word boundary
val whole_string : t -> t
Only matches the whole string
val longest : t -> t
Longest match
val shortest : t -> t
Shortest match
val first : t -> t
First match
val greedy : t -> t
Greedy
val non_greedy : t -> t
Non-greedy
val group : t -> t
Delimit a group
val no_group : t -> t
Remove all groups
val nest : t -> t
when matching against nest e
, only the group matching in the
last match of e will be considered as matching
val mark : t -> Mark.t * t
Mark a regexp. the markid can then be used to know if this regexp was used.
val set : string -> t
Any character of the string
val rg : char -> char -> t
Character ranges
val inter : t list -> t
Intersection of character sets
val diff : t -> t -> t
Difference of character sets
val compl : t list -> t
Complement of union
val any : t
Any character
val notnl : t
Any character but a newline
val alnum : t
val wordc : t
val alpha : t
val ascii : t
val blank : t
val cntrl : t
val digit : t
val graph : t
val lower : t
val print : t
val punct : t
val space : t
val upper : t
val xdigit : t
val case : t -> t
Case sensitive matching
val no_case : t -> t
Case insensitive matching
val pp : Stdlib.Format.formatter -> t -> unit
val pp_re : Stdlib.Format.formatter -> re -> unit
val print_re : Stdlib.Format.formatter -> re -> unit
Alias for Re.pp_re
. Deprecated
.
val witness : t -> string
witness r
generates a string s
such that execp (compile r) s
is
true
typesubstrings =
Group.t
Alias for Re.Group.t
. Deprecated
val get : Group.t -> int -> string
Same as Re.Group.get
. Deprecated
val get_ofs : Group.t -> int -> int * int
Same as Re.Group.offset
. Deprecated
val get_all : Group.t -> string array
Same as Re.Group.all
. Deprecated
val get_all_ofs : Group.t -> (int * int) array
Same as Re.Group.all_offset
. Deprecated
val test : Group.t -> int -> bool
Same as Re.Group.test
. Deprecated
typemarkid =
Mark.t
Alias for Re.Mark.t
. Deprecated
val marked : Group.t -> Mark.t -> bool
Same as Re.Mark.test
. Deprecated
val mark_set : Group.t -> Mark.Set.t
Same as Re.Mark.all
. Deprecated