Previous  Up  Next

Module String

module String: sig .. end
An extension of the standard StringLabels. If you open Core.Std, you'll get these in the String module.
type t = string 
include Comparable.S_binable
include Container.S0
include Hashable.S_binable
include Stringable.S
val max_length : int
Maximum length of a string.
val length : t -> int
val get : t -> int -> char
val set : t -> int -> char -> unit
val create : int -> t
val make : int -> char -> t
val copy : t -> t
val init : int -> f:(int -> char) -> t
val sub : t -> pos:int -> len:int -> t
val fill : t -> pos:int -> len:int -> char -> unit
val blit : src:t ->
       src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
val concat : ?sep:t -> t list -> t
concatanate all strings in the list using separator sep (default sep "")
val escaped : t -> t
Warning: Only returns a copy if changes are necessary! Special characters are represented by escape sequences, following the lexical conventions of Objective Caml.
val contains : ?pos:int -> ?len:int -> t -> char -> bool
val uppercase : t -> t
val lowercase : t -> t
val capitalize : t -> t
val uncapitalize : t -> t
val index : t -> char -> int option
val index_exn : t -> char -> int
val rindex : t -> char -> int option
val rindex_exn : t -> char -> int
val index_from : t -> int -> char -> int option
val index_from_exn : t -> int -> char -> int
val rindex_from : t -> int -> char -> int option
val rindex_from_exn : t -> int -> char -> int
val slice : t -> int -> int -> t
slice s start stop gets a slice of s between start and stop. start and stop will be normalized before the access. (viz. Array.normalize).
val to_list_rev : t -> char list
Returns the reversed list of characters contained in a list.
val nget : t -> int -> char
nget s i Gets the char at normalized position i in s.
val nset : t -> int -> char -> unit
nset s i c Sets the char at normalized position i to c.
val is_suffix : t -> suffix:t -> bool
is_suffix s ~suffix returns true if s ends with suffix.
val is_prefix : t -> prefix:t -> bool
is_prefix s ~prefix returns true if s starts with prefix.
val lsplit2_exn : t -> on:char -> t * t
If the string s contains the character on, then lsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the left).
Raises Not_found When on cannot be found in s
val rsplit2_exn : t -> on:char -> t * t
If the string s contains the character on, then rsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the right).
Raises Not_found When on cannot be found in s
val lsplit2 : t -> on:char -> (t * t) option
lsplit2 line ~on optionally returns line split into two strings around the * first appearance of on from the left
val rsplit2 : t -> on:char -> (t * t) option
rsplit2 line ~on optionally returns line split into two strings around the * first appearance of on from the right
val split : t -> on:char -> t list
split s ~on
Returns a list of substrings of s that are separated by on. Consecutive on characters will cause multiple empty strings in the result. Splitting the empty string returns a list of the empty string, not the empty list.
val split_on_chars : t -> on:char list -> t list
split_on_chars s ~on
Returns a list of all substrings of s that are separated by one of the chars from on. on are not grouped. So a grouping of on in the source string will produce multiple empty string splits in the result.
val lfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option
lfindi ?pos t ~f returns the smallest i >= pos such that f i t.[i], if there is such an i. By default, pos = 0.
val rfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option
rfindi ?pos t ~f returns the largest i <= pos such that f i t.[i], if there is such an i. By default pos = length t - 1.
val lstrip : ?drop:(char -> bool) -> t -> t
lstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the beginning of s.
val rstrip : ?drop:(char -> bool) -> t -> t
rstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the end of s.
val strip : ?drop:(char -> bool) -> t -> t
strip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the begining and end of s.
val map : t -> f:(char -> char) -> t
map f s applies f to each character in s, and returns the resulting string.
val mapi : t -> f:(int -> char -> char) -> t
mapi f s applies f to each character in s and its index, and returns the resulting string.
val foldi : t -> init:'a -> f:(int -> 'a -> char -> 'a) -> 'a
foldi works similarly to fold, but also pass in index of each character to f
val concat_map : ?sep:t ->
       t -> f:(char -> t) -> t
Like map, but allows replacement of a single character with zero or two or more characters.
val filter : t -> f:(char -> bool) -> t
filter s ~f:predicate discards characters not satisfying predicate
val tr : target:char -> replacement:char -> t -> t
tr target replacement s replaces every instance of target in s with replacement.
val tr_inplace : target:char -> replacement:char -> t -> unit
tr_inplace target replacement s destructively modifies s (in place!) replacing every instance of target in s with replacement.
val chop_suffix_exn : t -> suffix:t -> t
chop_suffix s ~suf returns a copy s without the trailing suff
Raises Invalid_argument is suff is not a suffix of s
val chop_prefix_exn : t -> prefix:t -> t
chop_prefix s ~pref returns a copy s without the leading pref
Raises Invalid_argument is pref is not a prefix of s
val chop_suffix : t -> suffix:t -> t option
val chop_prefix : t -> prefix:t -> t option
val suffix : t -> int -> t
suffix s n returns the longest suffix of s of length less than or equal to n
val prefix : t -> int -> t
prefix s n returns the longest prefix of s of length less than or equal to n
val drop_suffix : t -> int -> t
drop_suffix s n drops the longest suffix of s of length less than or equal to n
val drop_prefix : t -> int -> t
drop_prefix s n drops the longest prefix of s of length less than or equal to n
val concat_array : ?sep:t -> t array -> t
concat_array sep ar like String.concat, but operates on arrays
val hash : t -> int
slightly faster hash function on strings
val equal : t -> t -> bool
fast equality function on strings, doesn't use compare_val
val pp : Format.formatter -> t -> unit
This has to be public for interactive top-levels.
val is_empty : t -> bool
is_empty s returns true iff s is empty (i.e. its length is 0).
module Infix: sig .. end
val of_char : char -> t
val of_char_list : char list -> t
module Escaping: sig .. end
Operations for escaping and unescaping strings, with paramaterized escape and escapeworthy characters. 
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read_ml.reader
val bin_read_t_ : t Bin_prot.Unsafe_read_c.reader
val bin_read_t__ : (int -> t) Bin_prot.Unsafe_read_c.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write_ml.writer
val bin_write_t_ : t Bin_prot.Unsafe_write_c.writer
val bin_writer_t : t Bin_prot.Type_class.writer

Maximum length of a string.

concatanate all strings in the list using separator sep (default sep "")

Warning: Only returns a copy if changes are necessary! Special characters are represented by escape sequences, following the lexical conventions of Objective Caml.

slice s start stop gets a slice of s between start and stop. start and stop will be normalized before the access. (viz. Array.normalize).

Returns the reversed list of characters contained in a list.

nget s i Gets the char at normalized position i in s.

nset s i c Sets the char at normalized position i to c.

is_suffix s ~suffix returns true if s ends with suffix.

is_prefix s ~prefix returns true if s starts with prefix.

If the string s contains the character on, then lsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the left).

If the string s contains the character on, then rsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the right).

lsplit2 line ~on optionally returns line split into two strings around the * first appearance of on from the left

rsplit2 line ~on optionally returns line split into two strings around the * first appearance of on from the right

split s ~on

split_on_chars s ~on

lfindi ?pos t ~f returns the smallest i >= pos such that f i t.[i], if there is such an i. By default, pos = 0.

rfindi ?pos t ~f returns the largest i <= pos such that f i t.[i], if there is such an i. By default pos = length t - 1.

lstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the beginning of s.

rstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the end of s.

strip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the begining and end of s.

map f s applies f to each character in s, and returns the resulting string.

mapi f s applies f to each character in s and its index, and returns the resulting string.

foldi works similarly to fold, but also pass in index of each character to f

Like map, but allows replacement of a single character with zero or two or more characters.

filter s ~f:predicate discards characters not satisfying predicate

tr target replacement s replaces every instance of target in s with replacement.

tr_inplace target replacement s destructively modifies s (in place!) replacing every instance of target in s with replacement.

chop_suffix s ~suf returns a copy s without the trailing suff

chop_prefix s ~pref returns a copy s without the leading pref

suffix s n returns the longest suffix of s of length less than or equal to n

prefix s n returns the longest prefix of s of length less than or equal to n

drop_suffix s n drops the longest suffix of s of length less than or equal to n

drop_prefix s n drops the longest prefix of s of length less than or equal to n

concat_array sep ar like String.concat, but operates on arrays

slightly faster hash function on strings

fast equality function on strings, doesn't use compare_val

This has to be public for interactive top-levels.

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

Operations for escaping and unescaping strings, with paramaterized escape and escapeworthy characters. Escaping/unescaping using this module is more efficient than using Pcre. Benchmark code can be found in core/benchmarks/string_escaping.ml.

escape_gen_exn escapeworthy_map escape_char returns a function that will escape a string s as follows: if (c1,c2) is in escapeworthy_map, then all occurences of c1 are replaced by escape_char concatenated to c2.

Raises an exception if escapeworthy_map is not one-to-one. If escape_char is not in escapeworthy_map, then it will be escaped to itself.

escape ~escapeworthy ~escape_char s is 

        escape_gen_exn ~escapeworthy_map:(List.zip_exn escapeworthy escapeworthy)
          ~escape_char
. Duplicates and escape_char will be removed from escapeworthy. So, no exception will be raised

unescape_gen_exn is the inverse operation of escape_gen_exn. That is, 
      let escape = Staged.unstage (escape_gen_exn ~escapeworthy_map ~escape_char) in
      let unescape = Staged.unstage (unescape_gen_exn ~escapeworthy_map ~escape_char) in
      assert (s = unescape (escape s))
always succeed when ~escapeworthy_map is not causing exceptions.

unescape ~escape_char is defined as unescape_gen_exn ~map:[] ~escape_char

Any char in an escaped string is either escaping, escaped or literal. For example, for escaped string "0_a0__0" with escape_char as '_', pos 1 and 4 are escaping, 2 and 5 are escaped, and the rest are literal

is_char_escaping s ~escape_char pos return true if the char at pos is escaping, false otherwise.

is_char_escaped s ~escape_char pos return true if the char at pos is escaped, false otherwise.

is_literal s ~escape_char pos return true if the char at pos is not escaped or escaping.

index s ~escape_char char find the first literal (not escaped) instance of char in s starting from 0.

rindex s ~escape_char char find the first literal (not escaped) instance of char in s starting from the end of s and proceeding towards 0.

index_from s ~escape_char pos char find the first literal (not escaped) instance of char in s starting from pos and proceeding towards the end of s.

rindex_from s ~escape_char pos char find the first literal (not escaped) instance of char in s starting from pos and towards 0.

split s ~escape_char ~on

split_on_chars s ~on