package dune-private-libs

  1. Overview
  2. Docs
package dune-private-libs
Legend:
Library
Module
Module type
Parameter
Class
Class type
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.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct