Module Indexed_container.Make_with_creators

Parameters

module T : sig ... end

Signature

include Container.S1_with_creators with type 'a t := 'a T.t
val of_list : 'a list -> 'a T.t
val of_array : 'a array -> 'a T.t
val append : 'a T.t -> 'a T.t -> 'a T.t

E.g., append (of_list [1; 2]) (of_list [3; 4; 5]) is of_list [1; 2; 3; 4; 5]

val concat : 'a T.t T.t -> 'a T.t

Concatenates a nested container. The elements of the inner containers are concatenated together in order to give the result.

val map : 'a T.t -> f:('a -> 'b) -> 'b T.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 : 'a T.t -> f:('a -> bool) -> 'a T.t

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

val filter_map : 'a T.t -> f:('a -> 'b option) -> 'b T.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 concat_map : 'a T.t -> f:('a -> 'b T.t) -> 'b T.t

concat_map t ~f is equivalent to concat (map t ~f).

val partition_tf : 'a T.t -> f:('a -> bool) -> 'a T.t * 'a 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 : 'a T.t -> f:('a -> ('b, 'c) Base__.Either0.t) -> 'b T.t * 'c T.t

partition_map t ~f partitions t according to f.

include Container.S1 with type 'a t := 'a T.t
val mem : 'a T.t -> 'a -> equal:('a -> 'a -> bool) -> bool

Checks whether the provided element is there, using equal.

val length : 'a T.t -> int
val is_empty : 'a T.t -> bool
val iter : 'a T.t -> f:('a -> unit) -> unit
val fold : 'a T.t -> init:'acc -> f:('acc -> 'a -> '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 : 'a T.t -> init:'acc -> f:('acc -> 'a -> ('acc, 'e) Result.t) -> ('acc, 'e) 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 : 'a T.t -> init:'acc -> f:('acc -> 'a -> ('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 : 'a T.t -> f:('a -> 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 : 'a T.t -> f:('a -> 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 : 'a T.t -> f:('a -> bool) -> int

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

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

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

val find : 'a T.t -> f:('a -> bool) -> 'a option

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

val find_map : 'a T.t -> f:('a -> 'b option) -> 'b option

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

val to_list : 'a T.t -> 'a list
val to_array : 'a T.t -> 'a array
val min_elt : 'a T.t -> compare:('a -> 'a -> int) -> 'a option

Returns a minimum (resp maximum) element from the collection using the provided compare function, or None if the collection is empty. 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.

val max_elt : 'a T.t -> compare:('a -> 'a -> int) -> 'a 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 : 'a T.t -> init:_ -> f:(int -> _ -> 'a -> _) -> _
val iteri : 'a T.t -> f:(int -> 'a -> unit) -> unit
val existsi : 'a T.t -> f:(int -> 'a -> bool) -> bool
val for_alli : 'a T.t -> f:(int -> 'a -> bool) -> bool
val counti : 'a T.t -> f:(int -> 'a -> bool) -> int
val findi : 'a T.t -> f:(int -> 'a -> bool) -> (int * 'a) option
val find_mapi : 'a T.t -> f:(int -> 'a -> 'b option) -> 'b option
val init : int -> f:(int -> 'a) -> 'a T.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 : 'a T.t -> f:(int -> 'a -> 'b) -> 'b T.t

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

val filteri : 'a T.t -> f:(int -> 'a -> bool) -> 'a T.t
val filter_mapi : 'a T.t -> f:(int -> 'a -> 'b option) -> 'b T.t

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

val concat_mapi : 'a T.t -> f:(int -> 'a -> 'b T.t) -> 'b T.t

concat_mapi t ~f is like concat_map. Additionally, it passes the index as an argument.