package ocamlformat-mlx-lib

  1. Overview
  2. Docs
package ocamlformat-mlx-lib
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of Base.String
type t = string
val globalize : t -> t
include Sexplib0.Sexpable.S with type 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

sub with no bounds checking, and always returns a new copy

val subo : (t, t) Base.Blit.subo
include Base.Indexed_container.S0_with_creators with type t := t with type elt = char
include Base.Container.S0_with_creators with type t := t with type elt = char
type elt = char
val of_list : elt list -> t
val of_array : elt array -> t
val append : t -> t -> t

E.g., append (of_list [a; b]) (of_list [c; d; e]) is of_list [a; b; c; d; e]

val map : t -> f:(elt -> elt) -> t

map f (of_list [a1; ...; an]) applies f to a1, a2, ..., an, in order, and builds a result equivalent to of_list [f a1; ...; f an].

val filter : t -> f:(elt -> bool) -> t

filter t ~f returns all the elements of t that satisfy the predicate f.

val filter_map : t -> f:(elt -> elt option) -> t

filter_map t ~f applies f to every x in t. The result contains every y for which f x returns Some y.

val partition_tf : t -> f:(elt -> bool) -> t * t

partition_tf t ~f returns a pair t1, t2, where t1 is all elements of t that satisfy f, and t2 is all elements of t that do not satisfy f. The "tf" suffix is mnemonic to remind readers that the result is (trues, falses).

val partition_map : t -> f:(elt -> (elt, elt) Base__.Either0.t) -> t * t

partition_map t ~f partitions t according to f.

include Base.Container.S0 with type t := t with type elt := elt
val is_empty : t -> bool
val iter : t -> f:(elt -> unit) -> unit

iter must allow exceptions raised in f to escape, terminating the iteration cleanly. The same holds for all functions below taking an f.

val fold : t -> init:'acc -> f:('acc -> elt -> 'acc) -> 'acc

fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t.

val fold_result : t -> init:'acc -> f:('acc -> elt -> ('acc, 'e) Base.Result.t) -> ('acc, 'e) Base.Result.t

fold_result t ~init ~f is a short-circuiting version of fold that runs in the Result monad. If f returns an Error _, that value is returned without any additional invocations of f.

val fold_until : t -> init:'acc -> f:('acc -> elt -> ('acc, 'final) Container.Continue_or_stop.t) -> finish:('acc -> 'final) -> 'final

fold_until t ~init ~f ~finish is a short-circuiting version of fold. If f returns Stop _ the computation ceases and results in that value. If f returns Continue _, the fold will proceed. If f never returns Stop _, the final result is computed by finish.

Example:

type maybe_negative =
  | Found_negative of int
  | All_nonnegative of { sum : int }

(** [first_neg_or_sum list] returns the first negative number in [list], if any,
    otherwise returns the sum of the list. *)
let first_neg_or_sum =
  List.fold_until ~init:0
    ~f:(fun sum x ->
      if x < 0
      then Stop (Found_negative x)
      else Continue (sum + x))
    ~finish:(fun sum -> All_nonnegative { sum })
;;

let x = first_neg_or_sum [1; 2; 3; 4; 5]
val x : maybe_negative = All_nonnegative {sum = 15}

let y = first_neg_or_sum [1; 2; -3; 4; 5]
val y : maybe_negative = Found_negative -3
val exists : t -> f:(elt -> bool) -> bool

Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.

val for_all : t -> f:(elt -> bool) -> bool

Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.

val count : t -> f:(elt -> bool) -> int

Returns the number of elements for which the provided function evaluates to true.

val sum : (module Container.Summable with type t = 'sum) -> t -> f:(elt -> 'sum) -> 'sum

Returns the sum of f i for all i in the container.

val find : t -> f:(elt -> bool) -> elt option

Returns as an option the first element for which f evaluates to true.

val find_map : t -> f:(elt -> 'a option) -> 'a option

Returns the first evaluation of f that returns Some, and returns None if there is no such element.

val to_list : t -> elt list
val to_array : t -> elt array
val min_elt : t -> compare:(elt -> elt -> int) -> elt option

Returns a min (resp. max) element from the collection using the provided compare function. In case of a tie, the first element encountered while traversing the collection is returned. The implementation uses fold so it has the same complexity as fold. Returns None iff the collection is empty.

val max_elt : t -> compare:(elt -> elt -> int) -> elt option

These are all like their equivalents in Container except that an index starting at 0 is added as the first argument to f.

val foldi : t -> init:_ -> f:(int -> _ -> elt -> _) -> _
val iteri : t -> f:(int -> elt -> unit) -> unit
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

init n ~f is equivalent to of_list [f 0; f 1; ...; f (n-1)]. It raises an exception if n < 0.

val mapi : t -> f:(int -> elt -> elt) -> t

mapi is like map. Additionally, it passes in the index of each element as the first argument to the mapped function.

val filteri : t -> f:(int -> elt -> bool) -> t
val filter_mapi : t -> f:(int -> elt -> elt option) -> t

filter_mapi is like filter_map. Additionally, it passes in the index of each element as the first argument to the mapped function.

include Base.Identifiable.S with type t := t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Base.Stringable.S with type t := t
val of_string : string -> t
val to_string : t -> string
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix with type t := t
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

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
type comparator_witness = Base.String.comparator_witness
include Base.Pretty_printer.S with type t := t
val pp : Base.Formatter.t -> t -> unit
val hashable : t Base.Hashable.t
val compare__local : t -> t -> int
include Base.Invariant.S with type t := t
val invariant : t -> unit
val max_length : int

Maximum length of a string.

val mem : t -> char -> bool
val length : t -> int
val get : t -> int -> char
val unsafe_get : string -> int -> char

unsafe_get t i is like get t i but does not perform bounds checking. The caller must ensure that it is a memory-safe operation.

val make : int -> char -> t
val (^) : t -> t -> t

String append. Also available unqualified, but re-exported here for documentation purposes.

Note that a ^ b must copy both a and b into a newly-allocated result string, so a ^ b ^ c ^ ... ^ z is quadratic in the number of strings. String.concat does not have this problem -- it allocates the result buffer only once.

val concat : ?sep:t -> t list -> t

Concatenates all strings in the list using separator sep (with a default separator "").

val escaped : t -> t

Special characters are represented by escape sequences, following the lexical conventions of OCaml.

val contains : ?pos:int -> ?len:int -> t -> char -> bool
val uppercase : t -> t

Operates on the whole string using the US-ASCII character set, e.g. uppercase "foo" = "FOO".

val lowercase : t -> t
val capitalize : t -> t

Operates on just the first character using the US-ASCII character set, e.g. capitalize "foo" = "Foo".

val uncapitalize : t -> t
module Caseless = Base.String.Caseless

Caseless compares and hashes strings ignoring case, so that for example Caseless.equal "OCaml" "ocaml" and Caseless.("apple" < "Banana") are true.

index gives the index of the first appearance of char in the string when searching from left to right, or None if it's not found. rindex does the same but searches from the right.

For example, String.index "Foo" 'o' is Some 1 while String.rindex "Foo" 'o' is Some 2.

The _exn versions return the actual index (instead of an option) when char is found, and raise Stdlib.Not_found or Not_found_s otherwise.

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
val to_sequence : t -> char Base.Sequence.t

Produce a sequence of the characters in a string.

val of_sequence : char Base.Sequence.t -> t

Read the characters in a full sequence and produce a string.

module Search_pattern = Base.String.Search_pattern

Substring search and replace functions. They use the Knuth-Morris-Pratt algorithm (KMP) under the hood.

val substr_index : ?pos:int -> t -> pattern:t -> int option

Substring search and replace convenience functions. They call Search_pattern.create and then forget the preprocessed pattern when the search is complete. pos < 0 or pos >= length t result in no match (hence substr_index returns None and substr_index_exn raises). may_overlap indicates whether to report overlapping matches, see Search_pattern.index_all.

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

As with Search_pattern.replace_all, the result may still contain pattern.

val is_substring : t -> substring:t -> bool

is_substring ~substring:"bar" "foo bar baz" is true.

val is_substring_at : t -> pos:int -> substring:t -> bool

is_substring_at "foo bar baz" ~pos:4 ~substring:"bar" is true.

val to_list_rev : t -> char list

Returns the reversed list of characters contained in a list.

val rev : t -> t

rev t returns t in reverse order.

is_suffix s ~suffix returns true if s ends with suffix.

val is_suffix : t -> suffix:t -> bool
val is_prefix : t -> prefix:t -> bool

is_prefix s ~prefix returns true if s starts with prefix.

val lsplit2_exn : t -> on:char -> t * t

If the string s contains the character on, then lsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the left). Raises Stdlib.Not_found or Not_found_s when on cannot be found in s.

val rsplit2_exn : t -> on:char -> t * t

If the string s contains the character on, then rsplit2_exn s ~on returns a pair containing s split around the first appearance of on (from the right). Raises Stdlib.Not_found or Not_found_s when on cannot be found in s.

val lsplit2 : t -> on:char -> (t * t) option

lsplit2 s ~on optionally returns s split into two strings around the first appearance of on from the left.

val rsplit2 : t -> on:char -> (t * t) option

rsplit2 s ~on optionally returns s split into two strings around the first appearance of on from the right.

val split : t -> on:char -> t list

split s ~on returns a list of substrings of s that are separated by on. Consecutive on characters will cause multiple empty strings in the result. Splitting the empty string returns a list of the empty string, not the empty list.

val split_on_chars : t -> on:char list -> t list

split_on_chars s ~on returns a list of all substrings of s that are separated by one of the chars from on. on are not grouped. So a grouping of on in the source string will produce multiple empty string splits in the result.

val split_lines : t -> t list

split_lines t returns the list of lines that comprise t. The lines do not include the trailing "\n" or "\r\n".

val lfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option

lfindi ?pos t ~f returns the smallest i >= pos such that f i t.[i], if there is such an i. By default, pos = 0.

val rfindi : ?pos:int -> t -> f:(int -> char -> bool) -> int option

rfindi ?pos t ~f returns the largest i <= pos such that f i t.[i], if there is such an i. By default pos = length t - 1.

val lstrip : ?drop:(char -> bool) -> t -> t

lstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the beginning of s.

val rstrip : ?drop:(char -> bool) -> t -> t

rstrip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the end of s.

val strip : ?drop:(char -> bool) -> t -> t

strip ?drop s returns a string with consecutive chars satisfying drop (by default white space, e.g. tabs, spaces, newlines, and carriage returns) stripped from the beginning and end of s.

val concat_map : ?sep:t -> t -> f:(char -> t) -> t

Like map, but allows the replacement of a single character with zero or two or more characters.

val concat_mapi : ?sep:t -> t -> f:(int -> char -> t) -> t
val tr : target:char -> replacement:char -> t -> t

tr ~target ~replacement s replaces every instance of target in s with replacement.

val tr_multi : target:t -> replacement:t -> (t -> t) Base.Staged.t

tr_multi ~target ~replacement returns a function that replaces every instance of a character in target with the corresponding character in replacement.

If replacement is shorter than target, it is lengthened by repeating its last character. Empty replacement is illegal unless target also is.

If target contains multiple copies of the same character, the last corresponding replacement character is used. Note that character ranges are not supported, so ~target:"a-z" means the literal characters 'a', '-', and 'z'.

val chop_suffix_exn : t -> suffix:t -> t

chop_suffix_exn s ~suffix returns s without the trailing suffix, raising Invalid_argument if suffix is not a suffix of s.

val chop_prefix_exn : t -> prefix:t -> t

chop_prefix_exn s ~prefix returns s without the leading prefix, raising Invalid_argument if prefix is not a prefix of s.

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

chop_suffix_if_exists s ~suffix returns s without the trailing suffix, or just s if suffix isn't a suffix of s.

Equivalent to chop_suffix s ~suffix |> Option.value ~default:s, but avoids allocating the intermediate option.

val chop_prefix_if_exists : t -> prefix:t -> t

chop_prefix_if_exists s ~prefix returns s without the leading prefix, or just s if prefix isn't a prefix of s.

Equivalent to chop_prefix s ~prefix |> Option.value ~default:s, but avoids allocating the intermediate option.

val suffix : t -> int -> t

suffix s n returns the longest suffix of s of length less than or equal to n.

val prefix : t -> int -> t

prefix s n returns the longest prefix of s of length less than or equal to n.

val drop_suffix : t -> int -> t

drop_suffix s n drops the longest suffix of s of length less than or equal to n.

val drop_prefix : t -> int -> t

drop_prefix s n drops the longest prefix of s of length less than or equal to n.

val common_suffix : t list -> t

Produces the longest common suffix, or "" if the list is empty.

val common_prefix : t list -> t

Produces the longest common prefix, or "" if the list is empty.

val common_suffix_length : t list -> int

Produces the length of the longest common suffix, or 0 if the list is empty.

val common_prefix_length : t list -> int

Produces the length of the longest common prefix, or 0 if the list is empty.

val common_suffix2 : t -> t -> t

Produces the longest common suffix.

val common_prefix2 : t -> t -> t

Produces the longest common prefix.

val common_suffix2_length : t -> t -> int

Produces the length of the longest common suffix.

val common_prefix2_length : t -> t -> int

Produces the length of the longest common prefix.

val concat_array : ?sep:t -> t array -> t

concat_array sep ar like String.concat, but operates on arrays.

val concat_lines : ?crlf:bool -> string list -> string

Builds a multiline text from a list of lines. Each line is terminated and then concatenated. Equivalent to:

String.concat (List.map lines ~f:(fun line ->
  line ^ if crlf then "\r\n" else "\n"))
val hash : t -> int

Slightly faster hash function on strings.

val equal : t -> t -> bool

Fast equality function on strings, doesn't use compare_val.

val equal__local : t -> t -> bool
val of_char : char -> t
val of_char_list : char list -> t
val pad_left : ?char:char -> string -> len:int -> string

pad_left ?char s ~len returns s padded to the length len by adding characters char to the beginning of the string. If s is already longer than len it is returned unchanged.

val pad_right : ?char:char -> string -> len:int -> string

pad_right ?char ~s len returns s padded to the length len by adding characters char to the end of the string. If s is already longer than len it is returned unchanged.

val edit_distance : string -> string -> int

Reports the Levenshtein edit distance between two strings. Computes the minimum number of single-character insertions, deletions, and substitutions needed to transform one into the other.

For strings of length M and N, its time complexity is O(M*N) and its space complexity is O(min(M,N)).

module Escaping = Base.String.Escaping

Operations for escaping and unescaping strings, with parameterized escape and escapeworthy characters. Escaping/unescaping using this module is more efficient than using Pcre. Benchmark code can be found in core/benchmarks/string_escaping.ml.

module Utf8 = Base.String.Utf8

UTF-8 encoding. See Utf interface.

module Utf16le = Base.String.Utf16le

UTF-16 little-endian encoding. See Utf interface.

module Utf16be = Base.String.Utf16be

UTF-16 big-endian encoding. See Utf interface.

module Utf32le = Base.String.Utf32le

UTF-32 little-endian encoding. See Utf interface.

module Utf32be = Base.String.Utf32be

UTF-32 big-endian encoding. See Utf interface.

module type Utf = Base.String.Utf
module type Utf_as_string = Base.String.Utf_as_string
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