package containers

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type

Basic String Utils

Consider using Containers_string.KMP for pattern search, or Regex libraries.

type 'a gen = unit -> 'a option
type 'a sequence = ('a -> unit) -> unit
type 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]

Common Signature

module type S = sig ... end

Strings

val equal : string -> string -> bool
val compare : string -> string -> int
val hash : string -> int
val init : int -> (int -> char) -> string

Analog to 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_gen : char gen -> string
val of_seq : char sequence -> string
val of_klist : char klist -> string
val of_list : char list -> string
val of_array : char array -> string
val to_array : string -> char array
val find : ?start:int -> sub:string -> string -> int

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

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 ~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 -> len:int -> bool

is_sub ~sub i s j ~len returns true iff the substring of sub starting at position i and of length 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_pref ~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
  • since 0.17
val filter : (char -> bool) -> string -> string
  • 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
val blit : string -> int -> Bytes.t -> int -> int -> unit

Similar to 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 gen
val to_seq : string -> char sequence
val to_klist : string -> char klist
val to_list : string -> char list
val pp : Buffer.t -> string -> unit
val print : Format.formatter -> string -> unit

Print the string within quotes

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

Splitting

module Split : sig ... end

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

Slices

A contiguous part of a string

module Sub : sig ... end
OCaml

Innovation. Community. Security.