package core_kernel

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

This module extends Base.String.

type t = string
include Bin_prot.Binable.S with type t := t
include Typerep_lib.Typerepable.S with type t := t
val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t
val typename_of_t : t Typerep_lib.Typename.t
module Caseless : sig ... end
include module type of struct include Base.String end with type t := t with module Caseless := Base.String.Caseless
val blit : (t, bytes) Base__.Blit.blit
  • deprecated [since 2017-10] Use [Bytes.blit] instead
val blito : (t, bytes) Base__.Blit.blito
  • deprecated [since 2017-10] Use [Bytes.blito] instead
val unsafe_blit : (t, bytes) Base__.Blit.blit
  • deprecated [since 2017-10] Use [Bytes.unsafe_blit] instead
val sub : (t, t) Base__.Blit.sub
val subo : (t, t) Base__.Blit.subo
type elt = char
val mem : t -> elt -> bool
val is_empty : t -> bool
val iter : t -> f:(elt -> unit) -> unit
val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
val fold_result : t -> init:'accum -> f:('accum -> elt -> ('accum, 'e) Base__.Result.t) -> ('accum, 'e) Base__.Result.t
val fold_until : t -> init:'accum -> f: ('accum -> elt -> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) -> finish:('accum -> 'final) -> 'final
val exists : t -> f:(elt -> bool) -> bool
val for_all : t -> f:(elt -> bool) -> bool
val count : t -> f:(elt -> bool) -> int
val sum : (module Base__.Container_intf.Summable with type t = 'sum) -> t -> f:(elt -> 'sum) -> 'sum
val find : t -> f:(elt -> bool) -> elt option
val find_map : t -> f:(elt -> 'a option) -> 'a option
val to_list : t -> elt list
val to_array : t -> elt array
val min_elt : t -> compare:(elt -> elt -> int) -> elt option
val max_elt : t -> compare:(elt -> elt -> int) -> elt option
type comparator_witness = Base__String.comparator_witness
val max_length : int
val length : t -> int
val get : t -> int -> char
val unsafe_get : string -> int -> char
val create : int -> bytes
  • deprecated [since 2017-10] Use [Bytes.create] instead
val make : int -> char -> t
val copy : t -> t
  • deprecated [since 2018-03] Use [Bytes.copy] instead
val init : int -> f:(int -> char) -> t
val fill : bytes -> pos:int -> len:int -> char -> unit
  • deprecated [since 2017-10] Use [Bytes.fill] instead
val (^) : t -> t -> t
val concat : ?sep:t -> t list -> t
val escaped : t -> t
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 index_from : t -> int -> char -> int option
val index_from_exn : t -> int -> char -> int
val rindex : t -> char -> int option
val rindex_exn : t -> char -> int
val rindex_from : t -> int -> char -> int option
val rindex_from_exn : t -> int -> char -> int
module Search_pattern = String.Search_pattern
val substr_index : ?pos:int -> t -> pattern:t -> int option
val substr_index_exn : ?pos:int -> t -> pattern:t -> int
val substr_index_all : t -> may_overlap:bool -> pattern:t -> int list
val substr_replace_first : ?pos:int -> t -> pattern:t -> with_:t -> t
val substr_replace_all : t -> pattern:t -> with_:t -> t
val is_substring : t -> substring:t -> bool
val is_substring_at : t -> pos:int -> substring:t -> bool
val to_list_rev : t -> char list
val rev : t -> t
val is_suffix : t -> suffix:t -> bool
val is_prefix : t -> prefix:t -> bool
val lsplit2_exn : t -> on:char -> t * t
val rsplit2_exn : t -> on:char -> t * t
val lsplit2 : t -> on:char -> (t * t) option
val rsplit2 : t -> on:char -> (t * t) option
val split : t -> on:char -> t list
val split_on_chars : t -> on:char list -> t list
val split_lines : t -> t list
val lfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option
val rfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option
val lstrip : ?drop:(char -> bool) -> t -> t
val rstrip : ?drop:(char -> bool) -> t -> t
val strip : ?drop:(char -> bool) -> t -> t
val map : t -> f:(char -> char) -> t
val mapi : t -> f:(int -> char -> char) -> t
val foldi : t -> init:'a -> f:(int -> 'a -> char -> 'a) -> 'a
val concat_map : ?sep:t -> t -> f:(char -> t) -> t
val filter : t -> f:(char -> bool) -> t
val tr : target:char -> replacement:char -> t -> t
val tr_inplace : target:char -> replacement:char -> bytes -> unit
  • deprecated [since 2017-10] Use [Bytes.tr] instead
val tr_multi : target:t -> replacement:t -> (t -> t) Base__.Staged.t
val chop_suffix_exn : t -> suffix:t -> t
val chop_prefix_exn : t -> prefix:t -> t
val chop_suffix : t -> suffix:t -> t option
val chop_prefix : t -> prefix:t -> t option
val suffix : t -> int -> t
val prefix : t -> int -> t
val drop_suffix : t -> int -> t
val drop_prefix : t -> int -> t
val concat_array : ?sep:t -> t array -> t
val of_char : char -> t
val of_char_list : char list -> t
module Escaping = String.Escaping
val set : bytes -> int -> char -> unit
  • deprecated [since 2017-10] Use [Bytes.set] instead
val unsafe_set : bytes -> int -> char -> unit
  • deprecated [since 2017-10] Use [Bytes.unsafe_set] instead
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
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
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
val bin_t : t Bin_prot.Type_class.t
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
include Identifiable.S_common with type t := t
val sexp_of_t : t -> Ppx_sexp_conv_lib.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 Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound : max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound : min:t Base__.Maybe_bound.t -> max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare = String.Replace_polymorphic_compare
include Comparator.S with type t := t with type comparator_witness := comparator_witness
module Map : sig ... end
module Set : sig ... end
include Hashable.S_binable with type t := t
val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Table : sig ... end
module Hash_set : sig ... end
module Hash_queue : 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 gen, but without empty strings.

Like gen, 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 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