package re

  1. Overview
  2. Docs
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 = [
  1. | `Text of string
    (*

    Text between delimiters

    *)
  2. | `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

OCaml

Innovation. Community. Security.