re 1.9.0 · OCaml Package

type t

Regular expression

type re

Compiled regular expression

module Group : sig ... end

Manipulate matching groups.

type groups = Group.t

deprecated Use Group.t

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 exec.

val exec : ?pos:int -> ?len:int -> re -> string -> Group.t

exec re str matches str against the compiled expression re, and returns the matched groups if any.

parameter pos
optional beginning of the string (default 0)

parameter len
length of the substring of str that can be matched (default -1, meaning to the end of the string

raises Not_found
if the regular expression can't be found in str

val exec_opt : ?pos:int -> ?len:int -> re -> string -> Group.t option

Similar to exec, but returns an option instead of using an exception.

val execp : ?pos:int -> ?len:int -> re -> string -> bool

Similar to exec, but returns true if the expression matches, and false if it doesn't

val exec_partial : 
  ?pos:int ->
  ?len:int ->
  re ->
  string ->
  [ `Full | `Partial | `Mismatch ]

More detailed version of exec_p

module Mark : sig ... end

Marks

High Level Operations

type split_token = [

| `Text of string
(*
Text between delimiters
*)
| `Delim of Group.t
(*
Delimiter
*)

]

type 'a seq = 'a Seq.t

module Seq : sig ... end

val all : ?pos:int -> ?len:int -> re -> string -> Group.t list

Repeatedly calls exec on the given string, starting at given position and length.

type 'a gen = unit -> 'a option

val all_gen : ?pos:int -> ?len:int -> re -> string -> Group.t gen

deprecated Use Seq.all

val all_seq : ?pos:int -> ?len:int -> re -> string -> Group.t seq

deprecated Use Seq.all

val matches : ?pos:int -> ?len:int -> re -> string -> string list

Same as 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

deprecated Use Seq.matches

val matches_seq : ?pos:int -> ?len:int -> re -> string -> string seq

deprecated Use Seq.matches

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

deprecated Use Seq.split

val split_seq : ?pos:int -> ?len:int -> re -> string -> string seq

deprecated Use Seq.split

val split_full : ?pos:int -> ?len:int -> re -> string -> split_token list

split re s splits s into chunks separated by re. It yields the chunks along with the separators. For instance this can be used with a whitespace-matching re such as "[\t ]+".

val split_full_gen : ?pos:int -> ?len:int -> re -> string -> split_token gen

deprecated Use Seq.split_full

val split_full_seq : ?pos:int -> ?len:int -> re -> string -> split_token seq

deprecated Use Seq.split_full

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 pp_re. Deprecated

module View : sig ... end

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 Group.t. Deprecated

deprecated Use Group.t

val get : Group.t -> int -> string

Same as Group.get. Deprecated

deprecated Use Group.get

val get_ofs : Group.t -> int -> int * int

Same as Group.offset. Deprecated

deprecated Use Group.offset

val get_all : Group.t -> string array

Same as Group.all. Deprecated

deprecated Use Group.all

val get_all_ofs : Group.t -> (int * int) array

Same as Group.all_offset. Deprecated

deprecated Use Group.all_offset

val test : Group.t -> int -> bool

Same as Group.test. Deprecated

deprecated Use Group.test

type markid = Mark.t

Alias for Mark.t. Deprecated

deprecated Use Mark.

val marked : Group.t -> Mark.t -> bool

Same as Mark.test. Deprecated

deprecated Use Mark.test

val mark_set : Group.t -> Mark.Set.t

Same as Mark.all. Deprecated

deprecated Use Mark.all

module Emacs : sig ... end

Emacs-style regular expressions

module Glob : sig ... end

Shell-style regular expressions

module Perl : sig ... end

Perl-style regular expressions

module Pcre : sig ... end

module Posix : sig ... end

References:

module Str : sig ... end

Module Str: regular expressions and high-level string processing

package re