package ocamlformat-lib

  1. Overview
  2. Docs
package ocamlformat-lib
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of Base.String
type t = string
val globalize : t -> t
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
val sub : (t, t) Base__.Blit.sub
val unsafe_sub : t -> pos:int -> len:int -> t
val subo : (t, t) Base__.Blit.subo
type elt = char
val of_list : elt list -> t
val of_array : elt array -> t
val append : t -> t -> t
val map : t -> f:(elt -> elt) -> t
val filter : t -> f:(elt -> bool) -> t
val filter_map : t -> f:(elt -> elt option) -> t
val partition_tf : t -> f:(elt -> bool) -> t * t
val partition_map : t -> f:(elt -> (elt, elt) Base__.Either0.t) -> t * t
val is_empty : t -> bool
val iter : t -> f:(elt -> unit) -> unit
val fold : t -> init:'acc -> f:('acc -> elt -> 'acc) -> 'acc
val fold_result : t -> init:'acc -> f:('acc -> elt -> ('acc, 'e) Base__.Result.t) -> ('acc, 'e) Base__.Result.t
val fold_until : t -> init:'acc -> f:('acc -> elt -> ('acc, 'final) Base__Container_intf.Continue_or_stop.t) -> finish:('acc -> '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
val foldi : (t, elt, 'a) Base__Indexed_container_intf.foldi
val iteri : (t, elt) Base__Indexed_container_intf.iteri
val existsi : t -> f:(int -> elt -> bool) -> bool
val for_alli : t -> f:(int -> elt -> bool) -> bool
val counti : t -> f:(int -> elt -> bool) -> int
val findi : t -> f:(int -> elt -> bool) -> (int * elt) option
val find_mapi : t -> f:(int -> elt -> 'a option) -> 'a option
val init : int -> f:(int -> elt) -> t
val mapi : t -> f:(int -> elt -> elt) -> t
val filteri : t -> f:(int -> elt -> bool) -> t
val filter_mapi : t -> f:(int -> elt -> elt option) -> t
val hash_fold_t : t Base__Ppx_hash_lib.hash_fold
val t_of_sexp : Sexplib0__.Sexp.t -> t
val sexp_of_t : t -> Sexplib0__.Sexp.t
val of_string : string -> t
val to_string : t -> string
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 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
type comparator_witness = Base__String.comparator_witness
val comparator : (t, comparator_witness) Base__Comparator.comparator
val pp : Base__.Formatter.t -> t -> unit
val hashable : t Base__.Hashable.t
val invariant : t Base__Invariant_intf.inv
val max_length : int
val mem : t -> char -> bool
val length : t -> int
val get : t -> int -> char
val unsafe_get : string -> int -> char
val make : int -> char -> t
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
module Caseless : sig ... end
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 : sig ... end
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 concat_map : ?sep:t -> t -> f:(char -> t) -> t
val concat_mapi : ?sep:t -> t -> f:(int -> char -> t) -> t
val tr : target:char -> replacement:char -> t -> t
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 chop_suffix_if_exists : t -> suffix:t -> t
val chop_prefix_if_exists : t -> prefix:t -> t
val suffix : t -> int -> t
val prefix : t -> int -> t
val drop_suffix : t -> int -> t
val drop_prefix : t -> int -> t
val common_suffix : t list -> t
val common_prefix : t list -> t
val common_suffix_length : t list -> int
val common_prefix_length : t list -> int
val common_suffix2 : t -> t -> t
val common_prefix2 : t -> t -> t
val common_suffix2_length : t -> t -> int
val common_prefix2_length : t -> t -> int
val concat_array : ?sep:t -> t array -> t
val concat_lines : ?crlf:bool -> string list -> string
val hash : t -> int
val equal : t -> t -> bool
val of_char : char -> t
val of_char_list : char list -> t
val pad_left : ?char:char -> string -> len:int -> string
val pad_right : ?char:char -> string -> len:int -> string
module Escaping : sig ... end
val starts_with_whitespace : string -> bool

starts_with_whitespace s holds if s is non empty and starts with a whitespace character.

val ends_with_whitespace : string -> bool

ends_with_whitespace s holds if s is non empty and ends with a whitespace character.

val indent_of_line : string -> int option

indent_of_line s is the indentation at the beginning of s. Returns None if the first line of the string is only whitespaces or is empty.

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