package core

  1. Overview
  2. Docs
package core
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
include Bin_prot.Binable.S_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.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct