Up  Next

Module Re

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.

Compilation and execution of a regular expression

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.

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 string
val 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

High Level Operations

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
type split_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.

String expressions (literal match)

val str : string -> t
val char : char -> t

Basic operations on regular expressions

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

String, line, word

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

Match semantics

val longest : t -> t

Longest match

val shortest : t -> t

Shortest match

val first : t -> t

First match

Repeated match modifiers

val greedy : t -> t

Greedy

val non_greedy : t -> t

Non-greedy

Groups (or submatches)

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.

Character sets

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

Predefined character sets

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

Case modifiers

val case : t -> t

Case sensitive matching

val no_case : t -> t

Case insensitive matching

Internal debugging

val pp : Format.formatter -> t -> unit
val pp_re : Format.formatter -> re -> unit
val print_re : Format.formatter -> re -> unit

Alias for Re.pp_re. Deprecated

Experimental functions

.

val witness : t -> string

witness r generates a string s such that execp (compile r) s is true

Deprecated functions

type substrings = 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

type markid = 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