module BatString:String operations.sig..end
This module extends Stdlib's String module, go there for documentation on the rest of the functions and types.
If you're going to do a lot of string slicing, BatSubstring might be
a useful module to represent slices of strings, as it doesn't
allocate new strings on every operation.
Author(s): Xavier Leroy (base library), Nicolas Cannasse, David Teller, Edgar Friendly
val is_empty : string -> boolis_empty s returns true if s is the empty string, false
otherwise.
Usually a tad faster than comparing s with "".
Example (for some string s):
if String.is_empty s then "(Empty)" else s
val init : int -> (int -> char) -> stringinit l f returns the string of length l with the chars
f 0 , f 1 , f 2 ... f (l-1).
Example: String.init 256 char_of_int
val enum : string -> char BatEnum.tReturns an enumeration of the characters of a string.
Examples:
"foo" |> String.enum |> List.of_enum = ['f'; 'o'; 'o']
String.enum "a b c" // ((<>) ' ') |> String.of_enum = "abc"
val of_enum : char BatEnum.t -> string['f'; 'o'; 'o'] |> List.enum |> String.of_enum = "foo"val backwards : string -> char BatEnum.t
Examples:
"foo" |> String.backwards |> String.of_enum = "oof"
let rev s = String.backwards s |> String.of_enum
val of_backwards : char BatEnum.t -> string
Examples:
"foo" |> String.enum |> String.of_backwards = "oof"
"foo" |> String.backwards |> String.of_backwards = "foo"
let rev s = String.enum s |> String.of_backwards
val of_list : char list -> string
Example: ['c'; 'h'; 'a'; 'r'; 's'] |> String.of_list = "chars"
val to_list : string -> char list
Example: String.to_list "string" |> List.interleave ';' |> String.of_list = "s;t;r;i;n;g"
val of_int : int -> string
Example: String.of_int 56 = "56" && String.of_int (-1) = "-1"
val of_float : float -> string
Example: String.of_float 1.246 = "1.246"
val of_char : char -> string
Example: String.of_char 's' = "s"
val to_int : string -> intFailure "int_of_string" if the string does not represent an
integer. This follows OCaml's int literal rules, so "0x"
prefixes hexadecimal integers, "0o" for octal and "0b" for
binary. Underscores within the number are allowed for
readability but ignored.
Examples: String.to_int "8_480" = String.to_int "0x21_20"
try ignore(String.to_int "2,3"); false with Failure _ -> true
val to_float : string -> floatFailure "float_of_string" if the string does not represent a float.
Decimal points aren't required in the given string, as they are
for float literals in OCaml, but otherwise the rules for float
literals apply.
Examples: String.to_float "12.34e-1" = String.to_float "1.234"
String.to_float "1" = 1.
try ignore(String.to_float ""); false with Failure _ -> true
val map : (char -> char) -> string -> stringmap f s returns a string where all characters c in s have been
replaced by f c.
Example: String.map Char.uppercase "Five" = "FIVE"
*
val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'afold_left f a s is
f (... (f (f a s.[0]) s.[1]) ...) s.[n-1]
Examples: String.fold_left (fun li c -> c::li) [] "foo" = ['o';'o';'f']
String.fold_left max 'a' "apples" = 's'
val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'afold_right f s b is
f s.[0] (f s.[1] (... (f s.[n-1] b) ...))
Examples: String.fold_right List.cons "foo" [] = ['f';'o';'o']
String.fold_right (fun c a -> if c = ' ' then a+1 else a) "a b c" 0 = 2
val filter : (char -> bool) -> string -> stringfilter f s returns a copy of string s in which only
characters c such that f c = true remain.
Example: String.filter ((<>) ' ') "a b c" = "abc"
val filter_map : (char -> char option) -> string -> stringfilter_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).
Example: String.filter_map (function 'a'..'z' as c -> Some (Char.uppercase c) | _ -> None) "a b c" = "ABC"
val iteri : (int -> char -> unit) -> string -> unitString.iteri f s is equivalent to
f 0 s.[0]; f 1 s.[1]; ...; f len s.[len] where len is length of string s.
Example:
let letter_positions word =
let positions = Array.make 256 [] in
let count_letter pos c =
positions.(int_of_char c) <- pos :: positions.(int_of_char c) in
String.iteri count_letter word;
Array.mapi (fun c pos -> (char_of_int c, List.rev pos)) positions
|> Array.to_list
|> List.filter (fun (c,pos) -> pos <> [])
in
letter_positions "hello" = ['e',[1]; 'h',[0]; 'l',[2;3]; 'o',[4] ]
val find : string -> string -> intfind s x returns the starting index of the first occurrence of
string x within string s.
Note This implementation is optimized for short strings.
Raises Not_found if x is not a substring of s.
Example: String.find "foobarbaz" "bar" = 3
val find_from : string -> int -> string -> intfind_from s ofs x behaves as find s x but starts searching
at offset ofs. find s x is equivalent to find_from s 0 x.val rfind : string -> string -> intrfind s x returns the starting index of the last occurrence
of string x within string s.
Note This implementation is optimized for short strings.
Raises Not_found if x is not a substring of s.
Example: String.rfind "foobarbaz" "ba" = 6
val rfind_from : string -> int -> string -> intrfind_from s ofs x behaves as rfind s x but starts searching
from the right at offset ofs. rfind s x is equivalent to
rfind_from s (String.length s - 1) x.
Beware, it search between the beginning of the string to
the offset ofs, not between ofs and the end.
val ends_with : string -> string -> boolends_with s x returns true if the string s is ending with x, false otherwise.
Example: String.ends_with "foobarbaz" "rbaz" = true
val starts_with : string -> string -> boolstarts_with s x returns true if s is starting with x, false otherwise.
Example: String.starts_with "foobarbaz" "fooz" = false
val exists : string -> string -> boolexists str sub returns true if sub is a substring of str or
false otherwise.
Example: String.exists "foobarbaz" "obar" = true
val lchop : ?n:int -> string -> stringn characters.
By default n is 1.
If n is less than zero raises Invalid_argument.
If the string has n or less characters, returns the empty string.
Example:
String.lchop "Weeble" = "eeble"
String.lchop ~n:3 "Weeble" = "ble"
String.lchop ~n:1000 "Weeble" = ""
val rchop : ?n:int -> string -> stringn characters.
By default n is 1.
If n is less than zero raises Invalid_argument.
If the string has n or less characters , returns the empty string.
Example:
String.rchop "Weeble" = "Weebl"
String.rchop ~n:3 "Weeble" = "Wee"
String.rchop ~n:1000 "Weeble" = ""
val trim : string -> stringBatChar.is_whitespace).
Example: String.trim " \t foo\n " = "foo"
val quote : string -> string
Examples:
String.quote "foo" = "\"foo\""
String.quote "\"foo\"" = "\"\\\"foo\\\"\""
String.quote "\n" = "\"\\n\""
etc.
More precisely, the returned string conforms to the Caml syntax:
if printed, it outputs a representation of the input string as an
OCaml string litteral.
val left : string -> int -> stringleft r len returns the string containing the len first
characters of r. If r contains less than len characters, it
returns r.
Examples:
String.left "Weeble" 4 = "Weeb"
String.left "Weeble" 0 = ""
String.left "Weeble" 10 = "Weeble"
val right : string -> int -> stringleft r len returns the string containing the len last characters of r.
If r contains less than len characters, it returns r.
Example: String.right "Weeble" 4 = "eble"
val head : string -> int -> string
val tail : string -> int -> stringtail r pos returns the string containing all but the pos first characters of r
Example: String.tail "Weeble" 4 = "le"
val strip : ?chars:string -> string -> string
Examples:
String.strip " foo " = "foo"
String.strip ~chars:" ,()" " boo() bar()" = "boo() bar"
val replace_chars : (char -> string) -> string -> stringreplace_chars f s returns a string where all chars c of s have been
replaced by the string returned by f c.
Example: String.replace_chars (function ' ' -> "(space)" | c -> String.of_char c) "foo bar" = "foo(space)bar"
val replace : str:string -> sub:string -> by:string -> bool * stringreplace ~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.
Example: String.replace "foobarbaz" "bar" "rab" = (true, "foorabbaz")
val repeat : string -> int -> stringrepeat s n returns s ^ s ^ ... ^ s
Example: String.repeat "foo" 4 = "foofoofoofoo"
val split : string -> string -> string * stringsplit s sep splits the string s between the first
occurrence of sep, and returns the two parts before
and after the occurence (excluded).Not_found if the separator is not found.
Examples:
String.split "abcabcabc" "bc" = ("a","abcabc")
String.split "abcabcabc" "" = ("","abcabcabc")
val rsplit : string -> string -> string * stringrsplit s sep splits the string s between the last occurrence
of sep, and returns the two parts before and after the
occurence (excluded).Not_found if the separator is not found.
Example: String.rsplit "abcabcabc" "bc" = ("abcabca","")
val nsplit : string -> string -> string listnsplit s sep splits the string s into a list of strings
which are separated by sep (excluded).
nsplit "" _ returns the empty list.
Example: String.nsplit "abcabcabc" "bc" = ["a"; "a"; "a"; ""]
val join : string -> string list -> stringconcatval slice : ?first:int -> ?last:int -> string -> stringslice ?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.
Example: String.slice ~first:1 ~last:(-3) " foo bar baz" = "foo bar "
val splice : string -> int -> int -> string -> stringString.splice s off len rep cuts out the section of s
indicated by off and len and replaces it by rep
Negative indexes are interpreted as counting from the end
of the string. If off+len is greater than length s,
the end of the string is used, regardless of the value of
len.
If len is zero or negative, rep is inserted at position
off without replacing any of s.
Example: String.splice "foo bar baz" 3 5 "XXX" = "fooXXXbaz"
val explode : string -> char listexplode s returns the list of characters in the string s.
Example: String.explode "foo" = ['f'; 'o'; 'o']
val implode : char list -> stringimplode cs returns a string resulting from concatenating
the characters in the list cs.
Example: String.implode ['b'; 'a'; 'r'] = "bar"
val compare : String.t -> String.t -> intPervasives.compare. Along with the type t, this function compare
allows the module String to be passed as argument to the functors
Set.Make and Map.Make.
Example: String.compare "FOO" "bar" = -1 i.e. "FOO" < "bar"
val icompare : String.t -> String.t -> int
Example: String.icompare "FOO" "bar" = 1 i.e. "foo" > "bar"
module IString:BatInterfaces.OrderedTypewith type t = t
val numeric_compare : String.t -> String.t -> intAlgorithm: Ignore identical prefixes, if first character difference is numeric, parse the whole number as an int and compare.
Example: String.numeric_compare "xx32" "xx210" = -1
module NumString:BatInterfaces.OrderedTypewith type t = t
val print : 'a BatInnerIO.output -> string -> unit
Example: String.print stdout "foo\n"
val println : 'a BatInnerIO.output -> string -> unit
Example: String.println stdout "foo"
val print_quoted : 'a BatInnerIO.output -> string -> unitquote function.
String.print_quoted stdout "foo" prints "foo" (with the quotes).
String.print_quoted stdout "\"bar\"" prints "\"bar\"" (with the quotes).
String.print_quoted stdout "\n" prints "\n" (not the escaped
character, but '\' then 'n').
val t_printer : String.t BatValue_printer.tval unquoted_printer : String.t BatValue_printer.t