package regenerate

You can search for identifiers within the package.

in-package search v0.2.0

package regenerate

regenerate
- Regenerate
  - Make
    
    IMap
    
    Segment
    
    Sigma
    
    Sigma_star
    
    Word
  - Regex
  - SIGMA
  - Word
    
    List
    
    C
    
    S
    
    String
regenerate.segments
- Segments
  - OrderedMonoid
  - S
  - Trie
    
    Make
    
    W
    
    String
    
    WORD

Legend:
Library
Module
Module type
Parameter
Class
Class type

type nonrec char = char

include module type of struct include CCString end

Basic String Utils

type 'a sequence = ('a -> unit) -> unit

deprecated
use 'a iter instead

type 'a iter = ('a -> unit) -> unit

Fast internal iterator.

since 2.8

type 'a gen = unit -> 'a option

type 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]

Common Signature

module type S = CCString.S

Strings

include module type of struct include Stdlib.String end

val get : string -> int -> char

val create : int -> bytes

deprecated Use Bytes.create instead.

val make : int -> char -> string

val copy : string -> string

deprecated

val sub : string -> int -> int -> string

val fill : bytes -> int -> int -> char -> unit

deprecated Use Bytes.fill instead.

val concat : string -> string list -> string

val trim : string -> string

val escaped : string -> string

val index : string -> char -> int

val index_opt : string -> char -> int option

val rindex : string -> char -> int

val rindex_opt : string -> char -> int option

val index_from : string -> int -> char -> int

val index_from_opt : string -> int -> char -> int option

val rindex_from : string -> int -> char -> int

val rindex_from_opt : string -> int -> char -> int option

val contains : string -> char -> bool

val contains_from : string -> int -> char -> bool

val rcontains_from : string -> int -> char -> bool

val uppercase : string -> string

deprecated Use String.uppercase_ascii instead.

val lowercase : string -> string

deprecated Use String.lowercase_ascii instead.

val capitalize : string -> string

deprecated Use String.capitalize_ascii instead.

val uncapitalize : string -> string

deprecated Use String.uncapitalize_ascii instead.

type t = string

val to_seqi : t -> (int * char) Stdlib.Seq.t

val unsafe_get : string -> int -> char

val unsafe_set : bytes -> int -> char -> unit

deprecated

val unsafe_blit : string -> int -> bytes -> int -> int -> unit

val unsafe_fill : bytes -> int -> int -> char -> unit

deprecated

val equal : string -> string -> bool

Equality function on strings.

val compare : string -> string -> int

val is_empty : string -> bool

is_empty s returns true iff s is empty (i.e. its length is 0).

since 1.5

val hash : string -> int

val init : int -> (int -> char) -> string

Like Array.init.

since 0.3.3

val rev : string -> string

rev s returns the reverse of s.

since 0.17

val pad : ?side:[ `Left | `Right ] -> ?c:char -> int -> string -> string

pad n str ensures that str is at least n bytes long, and pads it on the side with c if it's not the case.

parameter side
determines where padding occurs (default: `Left).

parameter c
the char used to pad (default: ' ').

since 0.17

val of_char : char -> string

of_char 'a' is "a".

since 0.19

val of_gen : char gen -> string

Convert a gen of characters to a string.

val of_iter : char iter -> string

Convert a iter of characters to a string.

since 2.8

val of_std_seq : char Stdlib.Seq.t -> string

Convert a sequence of characters to a string.

since 2.8

val of_seq : char sequence -> string

deprecated use of_iter

val of_klist : char klist -> string

deprecated use of_std_seq

val of_list : char list -> string

Convert a list of characters to a string.

val of_array : char array -> string

Convert an array of characters to a string.

val to_array : string -> char array

Return the array of characters contained in the string.

val find : ?start:int -> sub:string -> string -> int

Find sub in string, returns its first index or -1.

val find_all : ?start:int -> sub:string -> string -> int gen

find_all ~sub s finds all occurrences of sub in s, even overlapping instances.

parameter start
starting position in s.

since 0.17

val find_all_l : ?start:int -> sub:string -> string -> int list

find_all_l ~sub s finds all occurrences of sub in s and returns them in a list.

parameter start
starting position in s.

since 0.17

val mem : ?start:int -> sub:string -> string -> bool

mem ~sub s is true iff sub is a substring of s.

since 0.12

val rfind : sub:string -> string -> int

Find sub in string from the right, returns its first index or -1. Should only be used with very small sub.

since 0.12

val replace : 
  ?which:[ `Left | `Right | `All ] ->
  sub:string ->
  by:string ->
  string ->
  string

replace ~sub ~by s replaces some occurrences of sub by by in s.

parameter which
decides whether the occurrences to replace are:
- `Left first occurrence from the left (beginning).
- `Right first occurrence from the right (end).
- `All all occurrences (default).

raises Invalid_argument
if sub = "".

since 0.14

val is_sub : sub:string -> int -> string -> int -> sub_len:int -> bool

is_sub ~sub i s j ~sub_len returns true iff the substring of sub starting at position i and of length sub_len is a substring of s starting at position j.

val repeat : string -> int -> string

The same string, repeated n times.

val prefix : pre:string -> string -> bool

prefix ~pre s returns true iff pre is a prefix of s.

val suffix : suf:string -> string -> bool

suffix ~suf s returns true iff suf is a suffix of s.

since 0.7

val chop_prefix : pre:string -> string -> string option

chop_prefix ~pre s removes pre from s if pre really is a prefix of s, returns None otherwise.

since 0.17

val chop_suffix : suf:string -> string -> string option

chop_suffix ~suf s removes suf from s if suf really is a suffix of s, returns None otherwise.

since 0.17

val take : int -> string -> string

take n s keeps only the n first chars of s.

since 0.17

val drop : int -> string -> string

drop n s removes the n first chars of s.

since 0.17

val take_drop : int -> string -> string * string

take_drop n s = take n s, drop n s.

since 0.17

val lines : string -> string list

lines s returns a list of the lines of s (splits along '\n').

since 0.10

val lines_gen : string -> string gen

lines_gen s returns a generator of the lines of s (splits along '\n').

since 0.10

val concat_gen : sep:string -> string gen -> string

concat_gen ~sep g concatenates all strings of g, separated with sep.

since 0.10

val unlines : string list -> string

unlines l concatenates all strings of l, separated with '\n'.

since 0.10

val unlines_gen : string gen -> string

unlines_gen g concatenates all strings of g, separated with '\n'.

since 0.10

val set : string -> int -> char -> string

set s i c creates a new string which is a copy of s, except for index i, which becomes c.

raises Invalid_argument
if i is an invalid index.

since 0.12

val iter : (char -> unit) -> string -> unit

Alias to String.iter.

since 0.12

val iteri : (int -> char -> unit) -> string -> unit

Iter on chars with their index.

since 0.12

val map : (char -> char) -> string -> string

Map chars.

since 0.12

val mapi : (int -> char -> char) -> string -> string

Map chars with their index.

since 0.12

val filter_map : (char -> char option) -> string -> string

filter_map f s calls (f a0) (f a1) ... (f an) where a0 ... an are the characters of s. It returns the string of characters ci such as f ai = Some ci (when f returns None, the corresponding element of s is discarded).

since 0.17

val filter : (char -> bool) -> string -> string

filter f s discards characters not satisfying f.

since 0.17

val flat_map : ?sep:string -> (char -> string) -> string -> string

Map each chars to a string, then concatenates them all.

parameter sep
optional separator between each generated string.

since 0.12

val for_all : (char -> bool) -> string -> bool

True for all chars?

since 0.12

val exists : (char -> bool) -> string -> bool

True for some char?

since 0.12

include S with type t := string

val length : string -> int

Return the length (number of characters) of the given string.

val blit : string -> int -> Stdlib.Bytes.t -> int -> int -> unit

Like String.blit. Compatible with the -safe-string option.

raises Invalid_argument
if indices are not valid.

val fold : ('a -> char -> 'a) -> 'a -> string -> 'a

Fold on chars by increasing index.

since 0.7

Conversions

val to_gen : string -> char CCString.gen

Return the gen of characters contained in the string.

val to_iter : string -> char CCString.iter

Return the iter of characters contained in the string.

since 2.8

val to_std_seq : string -> char Stdlib.Seq.t

to_std_seq s returns a Seq.t of the bytes in s.

since 2.8

val to_klist : string -> char CCString.klist

deprecated use to_std_seq

val to_list : string -> char list

Return the list of characters contained in the string.

val pp_buf : Stdlib.Buffer.t -> string -> unit

Renamed from pp since 2.0.

val drop_while : (char -> bool) -> t -> t

drop_while f s discards any characters starting from the left, up to the first character c not satisfying f c.

since 2.2

val rdrop_while : (char -> bool) -> t -> t

rdrop_while f s discards any characters starting from the right, up to the first character c not satisfying f c.

since 2.2

val ltrim : t -> t

Trim space on the left (see String.trim for more details).

since 1.2

val rtrim : t -> t

Trim space on the right (see String.trim for more details).

since 1.2

Operations on 2 strings

val map2 : (char -> char -> char) -> string -> string -> string

Map pairs of chars.

raises Invalid_argument
if the strings have not the same length.

since 0.12

val iter2 : (char -> char -> unit) -> string -> string -> unit

Iterate on pairs of chars.

raises Invalid_argument
if the strings have not the same length.

since 0.12

val iteri2 : (int -> char -> char -> unit) -> string -> string -> unit

Iterate on pairs of chars with their index.

raises Invalid_argument
if the strings have not the same length.

since 0.12

val fold2 : ('a -> char -> char -> 'a) -> 'a -> string -> string -> 'a

Fold on pairs of chars.

raises Invalid_argument
if the strings have not the same length.

since 0.12

val for_all2 : (char -> char -> bool) -> string -> string -> bool

All pairs of chars respect the predicate?

raises Invalid_argument
if the strings have not the same length.

since 0.12

val exists2 : (char -> char -> bool) -> string -> string -> bool

Exists a pair of chars?

raises Invalid_argument
if the strings have not the same length.

since 0.12

Ascii functions

Those functions are deprecated in String since 4.03, so we provide a stable alias for them even in older versions.

val capitalize_ascii : string -> string

See String.

since 0.18

val uncapitalize_ascii : string -> string

See String.

since 0.18

val uppercase_ascii : string -> string

See String.

since 0.18

val lowercase_ascii : string -> string

See String.

since 0.18

val equal_caseless : string -> string -> bool

Comparison without respect to ascii lowercase.

since 1.2

Finding

A relatively efficient algorithm for finding sub-strings.

since 1.0

module Find = CCString.Find

Splitting

module Split = CCString.Split

val split_on_char : char -> string -> string list

Split the string along the given char.

since 1.2

val split : by:string -> string -> string list

Alias to Split.list_cpy.

since 1.2

Utils

val compare_versions : string -> string -> int

compare_versions a b compares version strings a and b, considering that numbers are above text.

since 0.13

val compare_natural : string -> string -> int

Natural Sort Order, comparing chunks of digits as natural numbers. https://en.wikipedia.org/wiki/Natural_sort_order

since 1.3

val edit_distance : string -> string -> int

Edition distance between two strings. This satisfies the classical distance axioms: it is always positive, symmetric, and satisfies the formula distance a b + distance b c >= distance a c.

Slices

A contiguous part of a string

module Sub = CCString.Sub

val empty : string

val singleton : char -> string

val cons : char -> string -> string

val append : string -> string -> string

val compare_char : Stdlib.Char.t -> Stdlib.Char.t -> int

val pp : Stdlib.Format.formatter -> string -> unit

val to_seq : string -> (char -> unit) -> unit