package core

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

This module extends Base.String.

val globalize : string -> string
val t_sexp_grammar : string Sexplib0.Sexp_grammar.t
val sub : (string, string) Base__.Blit.sub
val unsafe_sub : string -> pos:int -> len:int -> string
val subo : (string, string) Base__.Blit.subo
type elt = char
val of_list : elt list -> string
val of_array : elt array -> string
val append : string -> string -> string
val map : string -> f:(elt -> elt) -> string
val filter : string -> f:(elt -> bool) -> string
val filter_map : string -> f:(elt -> elt option) -> string
val partition_tf : string -> f:(elt -> bool) -> string * string
val partition_map : string -> f:(elt -> (elt, elt) Base__.Either0.t) -> string * string
val is_empty : string -> bool
val iter : string -> f:(elt -> unit) -> unit
val fold : string -> init:'acc -> f:('acc -> elt -> 'acc) -> 'acc
val fold_result : string -> init:'acc -> f:('acc -> elt -> ('acc, 'e) Base__.Result.t) -> ('acc, 'e) Base__.Result.t
val fold_until : string -> init:'acc -> f:('acc -> elt -> ('acc, 'final) Base__Container_intf.Continue_or_stop.t) -> finish:('acc -> 'final) -> 'final
val exists : string -> f:(elt -> bool) -> bool
val for_all : string -> f:(elt -> bool) -> bool
val count : string -> f:(elt -> bool) -> int
val sum : (module Base__Container_intf.Summable with type t = 'sum) -> string -> f:(elt -> 'sum) -> 'sum
val find : string -> f:(elt -> bool) -> elt option
val find_map : string -> f:(elt -> 'a option) -> 'a option
val to_list : string -> elt list
val to_array : string -> elt array
val min_elt : string -> compare:(elt -> elt -> int) -> elt option
val max_elt : string -> compare:(elt -> elt -> int) -> elt option
val foldi : (string, elt, 'a) Base__Indexed_container_intf.foldi
val iteri : (string, elt) Base__Indexed_container_intf.iteri
val existsi : string -> f:(int -> elt -> bool) -> bool
val for_alli : string -> f:(int -> elt -> bool) -> bool
val counti : string -> f:(int -> elt -> bool) -> int
val findi : string -> f:(int -> elt -> bool) -> (int * elt) option
val find_mapi : string -> f:(int -> elt -> 'a option) -> 'a option
val init : int -> f:(int -> elt) -> string
val mapi : string -> f:(int -> elt -> elt) -> string
val filteri : string -> f:(int -> elt -> bool) -> string
val filter_mapi : string -> f:(int -> elt -> elt option) -> string
type comparator_witness = Base__String.comparator_witness
val compare__local : string Base__Ppx_compare_lib.compare__local
val invariant : string Base__Invariant_intf.inv
val max_length : int
val mem : string -> char -> bool
val length : string -> int
val get : string -> int -> char
val unsafe_get : string -> int -> char
val make : int -> char -> string
val (^) : string -> string -> string
val concat : ?sep:string -> string list -> string
val escaped : string -> string
val contains : ?pos:int -> ?len:int -> string -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val index : string -> char -> int option
val index_exn : string -> char -> int
val index_from : string -> int -> char -> int option
val index_from_exn : string -> int -> char -> int
val rindex : string -> char -> int option
val rindex_exn : string -> char -> int
val rindex_from : string -> int -> char -> int option
val rindex_from_exn : string -> int -> char -> int
val to_sequence : string -> char Base__.Sequence.t
val of_sequence : char Base__.Sequence.t -> string
module Search_pattern : sig ... end
val substr_index : ?pos:int -> string -> pattern:string -> int option
val substr_index_exn : ?pos:int -> string -> pattern:string -> int
val substr_index_all : string -> may_overlap:bool -> pattern:string -> int list
val substr_replace_first : ?pos:int -> string -> pattern:string -> with_:string -> string
val substr_replace_all : string -> pattern:string -> with_:string -> string
val is_substring : string -> substring:string -> bool
val is_substring_at : string -> pos:int -> substring:string -> bool
val to_list_rev : string -> char list
val rev : string -> string
val is_suffix : string -> suffix:string -> bool
val is_prefix : string -> prefix:string -> bool
val lsplit2_exn : string -> on:char -> string * string
val rsplit2_exn : string -> on:char -> string * string
val lsplit2 : string -> on:char -> (string * string) option
val rsplit2 : string -> on:char -> (string * string) option
val split : string -> on:char -> string list
val split_on_chars : string -> on:char list -> string list
val split_lines : string -> string list
val lfindi : ?pos:int -> string -> f:(int -> char -> bool) -> int option
val rfindi : ?pos:int -> string -> f:(int -> char -> bool) -> int option
val lstrip : ?drop:(char -> bool) -> string -> string
val rstrip : ?drop:(char -> bool) -> string -> string
val strip : ?drop:(char -> bool) -> string -> string
val concat_map : ?sep:string -> string -> f:(char -> string) -> string
val concat_mapi : ?sep:string -> string -> f:(int -> char -> string) -> string
val tr : target:char -> replacement:char -> string -> string
val tr_multi : target:string -> replacement:string -> (string -> string) Base__.Staged.t
val chop_suffix_exn : string -> suffix:string -> string
val chop_prefix_exn : string -> prefix:string -> string
val chop_suffix : string -> suffix:string -> string option
val chop_prefix : string -> prefix:string -> string option
val chop_suffix_if_exists : string -> suffix:string -> string
val chop_prefix_if_exists : string -> prefix:string -> string
val suffix : string -> int -> string
val prefix : string -> int -> string
val drop_suffix : string -> int -> string
val drop_prefix : string -> int -> string
val common_suffix : string list -> string
val common_prefix : string list -> string
val common_suffix_length : string list -> int
val common_prefix_length : string list -> int
val common_suffix2 : string -> string -> string
val common_prefix2 : string -> string -> string
val common_suffix2_length : string -> string -> int
val common_prefix2_length : string -> string -> int
val concat_array : ?sep:string -> string array -> string
val concat_lines : ?crlf:bool -> string list -> string
val equal__local : string -> string -> bool
val of_char : char -> string
val of_char_list : char list -> string
val pad_left : ?char:char -> string -> len:int -> string
val pad_right : ?char:char -> string -> len:int -> string
val edit_distance : string -> string -> int
module Escaping : sig ... end
type t = string
include Bin_prot.Binable.S_local with type t := t
include Bin_prot.Binable.S_local_only_functions with type t := t
val bin_size_t__local : t Bin_prot.Size.sizer_local
val bin_write_t__local : t Bin_prot.Write.writer_local
include Typerep_lib.Typerepable.S with type t := t
val typename_of_t : t Typerep_lib.Typename.t
module Caseless : sig ... end

Caseless compares and hashes strings ignoring case, so that for example Caseless.equal "OCaml" "ocaml" and Caseless.("apple" < "Banana") are true, and Caseless.Map, Caseless.Table lookup and Caseless.Set membership is case-insensitive.

val slice : t -> int -> int -> t

slice t start stop returns a new string including elements t.(start) through t.(stop-1), normalized Python-style with the exception that stop = 0 is treated as stop = length t.

val nget : t -> int -> char

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

val take_while : t -> f:(char -> bool) -> t

take_while s ~f returns the longest prefix of s satisfying for_all prefix ~f (See lstrip to drop such a prefix)

val rtake_while : t -> f:(char -> bool) -> t

rtake_while s ~f returns the longest suffix of s satisfying for_all suffix ~f (See rstrip to drop such a suffix)

include Hexdump.S with type t := t
module Hexdump : sig ... end
include Identifiable.S with type t := t and type comparator_witness := comparator_witness
include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
include Ppx_hash_lib.Hashable.S with type t := t
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0__.Sexp.t -> t
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
val sexp_of_t : t -> Sexplib0.Sexp.t
val of_string : string -> t
val to_string : t -> string
val pp : Base__.Formatter.t -> t -> unit
include Comparable.S_binable with type t := t with type comparator_witness := comparator_witness
include Base.Comparable.S with type t := t with type comparator_witness := comparator_witness
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
val validate_lbound : min:t Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Maybe_bound.t -> t Validate.check
val validate_bound : min:t Maybe_bound.t -> max:t Maybe_bound.t -> t Validate.check
module Replace_polymorphic_compare : sig ... end
include Comparator.S with type t := t with type comparator_witness := comparator_witness
include Hashable.S_binable with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : t Base__Ppx_hash_lib.hash_fold
val hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core__.Hashtbl.Hashable.t
module Table : Hashtbl.S_binable with type key = t
module Hash_set : Hash_set.S_binable with type elt = t
module Hash_queue : Hash_queue.S with type key = t
include Diffable.S_atomic with type t := t
module Diff : sig ... end
include Quickcheckable.S with type t := t
val quickcheck_generator : t Base_quickcheck.Generator.t
val quickcheck_observer : t Base_quickcheck.Observer.t
val quickcheck_shrinker : t Base_quickcheck.Shrinker.t
val gen_nonempty : t Quickcheck.Generator.t

Like quickcheck_generator, but without empty strings.

Like quickcheck_generator, but generate strings with the given distribution of characters.

val gen_nonempty' : char Quickcheck.Generator.t -> t Quickcheck.Generator.t

Like gen', but without empty strings.

val gen_with_length : int -> char Quickcheck.Generator.t -> t Quickcheck.Generator.t

Like gen', but generate strings with the given length.

module type Utf = sig ... end
module type Utf_as_string = Utf with type t = private string

Iterface for Unicode encodings, specialized for string representation.

module Utf8 : Utf with type t = {Utf8}27.t and type comparator_witness = {Utf8}27.comparator_witness
module Utf16le : Utf with type t = {Utf16le}28.t and type comparator_witness = {Utf16le}28.comparator_witness
module Utf16be : Utf with type t = {Utf16be}29.t and type comparator_witness = {Utf16be}29.comparator_witness
module Utf32le : Utf with type t = Base.String.Utf32le.t and type comparator_witness = Base.String.Utf32le.comparator_witness
module Utf32be : Utf with type t = Base.String.Utf32be.t and type comparator_witness = Base.String.Utf32be.comparator_witness
module Stable : sig ... end

Note that string is already stable by itself, since as a primitive type it is an integral part of the sexp / bin_io protocol. String.Stable exists only to introduce String.Stable.Set, String.Stable.Map, String.Stable.Table, and provide interface uniformity with other stable types.

OCaml

Innovation. Community. Security.