Up  

Module ExtString.String


module String: sig .. end

New Functions


val init : int -> (int -> char) -> string
init l f returns the string of length l with the chars f 0 , f 1 , f 2 ... f (l-1).
val find : string -> string -> int
find s x returns the starting index of the string x within the string s or raises Invalid_string if x is not a substring of s.
val split : string -> string -> string * string
split s sep splits the string s between the first occurrence of sep. raises Invalid_string if the separator is not found.
val nsplit : string -> string -> string list
nsplit s sep splits the string s into a list of strings which are separated by sep.
val join : string -> string list -> string
Same as concat
val slice : ?first:int -> ?last:int -> string -> string
slice ?first ?last s returns a "slice" of the string which corresponds to the characters s.[first], s.[first+1], ..., s[last-1]. Note that the character at index last is not included! If first is omitted it defaults to the start of the string, i.e. index 0, and if last is omitted is defaults to point just past the end of s, i.e. length s. Thus, slice s is equivalent to copy s.

Negative indexes are interpreted as counting from the end of the string. For example, slice ~last:-2 s will return the string s, but without the last two characters.

This function never raises any exceptions. If the indexes are out of bounds they are automatically clipped.

val lchop : string -> string
Returns the same string but without the first character. does nothing if the string is empty.
val rchop : string -> string
Returns the same string but without the last character. does nothing if the string is empty.
val of_int : int -> string
Returns the string representation of an int.
val of_float : float -> string
Returns the string representation of an float.
val of_char : char -> string
Returns a string containing one given character.
val to_int : string -> int
Returns the integer represented by the given string or raises Invalid_string if the string does not represent an integer.
val to_float : string -> float
Returns the float represented by the given string or raises Invalid_string if the string does not represent a float.
val ends_with : string -> string -> bool
ends_with s x returns true if the string s is ending with x.
val starts_with : string -> string -> bool
starts_with s x return true if s is starting with x.
val map : (char -> char) -> string -> string
map f s returns a string where all characters c in s have been replaced by f c. *
val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a
fold_left f a s is f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]
val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a
fold_right f s b is f s.[0] (f s.[1] (... (f s.[n-1] b) ...))
val explode : string -> char list
explode s returns the list of characters in the string s.
val implode : char list -> string
implode cs returns a string resulting from concatenating the characters in the list cs.
val strip : ?chars:string -> string -> string
Returns the string without the chars if they are at the beginning or at the end of the string. By default chars are " \t\r\n".
val exists : string -> string -> bool
exists str sub returns true if sub is a substring of str or false otherwise.
val replace_chars : (char -> string) -> string -> string
replace_chars f s returns a string where all chars c of s have been replaced by the string returned by f c.
val replace : str:string -> sub:string -> by:string -> bool * string
replace ~str ~sub ~by returns a tuple constisting of a boolean and a string where the first occurrence of the string sub within str has been replaced by the string by. The boolean is true if a subtitution has taken place.
val lazy_concat : string Lazy.t -> string Lazy.t -> string Lazy.t
lazy_concat s1 s2 concats the two suspensions if the result is forced. You can concatenate the two lazy strings, and get the garantie, that is will done only once, and only if the hole string is forced.

Older Functions



Please refer to the Ocaml Manual for documentation of these functions.
val length : string -> int
val get : string -> int -> char
val set : string -> int -> char -> unit
val create : int -> string
val make : int -> char -> string
val copy : string -> string
val sub : string -> int -> int -> string
val fill : string -> int -> int -> char -> unit
val blit : string -> int -> string -> int -> int -> unit
val concat : string -> string list -> string
val iter : (char -> unit) -> string -> unit
val escaped : string -> string
val index : string -> char -> int
val rindex : string -> char -> int
val index_from : string -> int -> char -> int
val rindex_from : string -> int -> char -> int
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
type t = string 
val compare : t -> t -> int