package GT

  1. Overview
  2. Docs
Generic programming with extensible transformations

Install

Dune Dependency

github.com Readme Edit opam file Versions (9)

Authors

  1. H
    https://github.com/dboulytchev
  2. H
    https://github.com/Kakadu

Maintainers

  1. K
    kakadu.hafanana@gmail.com

Sources

v0.3.0.zip
sha256=58aa091948383ffa6c452b89880becae980ae32cc3a4969fe1c636e46810db69
sha512=ee878ba4c2ee16f5b77f4b4e98664d53e91b7a710b9162905b9a43118a03e9c0d7b378a13e104e16a84556bca1176026d93f11934d69eecb459b771e9340ffd7

doc/GT.common/GTCommon/HelpersBase/List/index.html

Module HelpersBase.List

include module type of struct include Base.List end
type !'a t = 'a list
val compare : 'a Base__Ppx_compare_lib.compare -> 'a t Base__Ppx_compare_lib.compare
val hash_fold_t : 'a Base__Ppx_hash_lib.hash_fold -> 'a t Base__Ppx_hash_lib.hash_fold
val t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.t
val t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a t Sexplib0.Sexp_grammar.t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result : 'a t -> init:'accum -> f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) -> ('accum, 'e) Base__.Result.t
val fold_until : 'a t -> init:'accum -> f:('accum -> 'a -> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) -> finish:('accum -> 'final) -> 'final
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val sum : (module Base__.Container_intf.Summable with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
val invariant : 'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
module Cartesian_product : sig ... end
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (>>|) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix : sig ... end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_unit : unit t list -> unit t
module Let_syntax : sig ... end
module Or_unequal_lengths : sig ... end
val of_list : 'a t -> 'a t
val nth : 'a t -> int -> 'a option
val nth_exn : 'a t -> int -> 'a
val rev : 'a t -> 'a t
val rev_append : 'a t -> 'a t -> 'a t
val unordered_append : 'a t -> 'a t -> 'a t
val rev_map : 'a t -> f:('a -> 'b) -> 'b t
val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
val iter2 : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit Or_unequal_lengths.t
val rev_map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
val rev_map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t Or_unequal_lengths.t
val fold2_exn : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
val fold2 : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c Or_unequal_lengths.t
val for_alli : 'a t -> f:(int -> 'a -> bool) -> bool
val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
val for_all2 : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool Or_unequal_lengths.t
val existsi : 'a t -> f:(int -> 'a -> bool) -> bool
val exists2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
val exists2 : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool Or_unequal_lengths.t
val filter : 'a t -> f:('a -> bool) -> 'a t
val rev_filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t
val partition_map : 'a t -> f:('a -> ('b, 'c) Base__.Either0.t) -> 'b t * 'c t
val partition3_map : 'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c | `Trd of 'd ]) -> 'b t * 'c t * 'd t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val partition_result : ('ok, 'error) Base__.Result.t t -> 'ok t * 'error t
val split_n : 'a t -> int -> 'a t * 'a t
val sort : 'a t -> compare:('a -> 'a -> int) -> 'a t
val stable_sort : 'a t -> compare:('a -> 'a -> int) -> 'a t
val merge : 'a t -> 'a t -> compare:('a -> 'a -> int) -> 'a t
val hd : 'a t -> 'a option
val tl : 'a t -> 'a t option
val hd_exn : 'a t -> 'a
val tl_exn : 'a t -> 'a t
val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option
val findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a
val find_exn : 'a t -> f:('a -> bool) -> 'a
val find_map_exn : 'a t -> f:('a -> 'b option) -> 'b
val find_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b option
val find_mapi_exn : 'a t -> f:(int -> 'a -> 'b option) -> 'b
val append : 'a t -> 'a t -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val folding_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'c t
val folding_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'c t
val fold_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'b * 'c t
val fold_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'b * 'c t
val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t
val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t Or_unequal_lengths.t
val rev_map3_exn : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t
val rev_map3 : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t Or_unequal_lengths.t
val map3_exn : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t
val map3 : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t Or_unequal_lengths.t
val rev_map_append : 'a t -> 'b t -> f:('a -> 'b) -> 'b t
val fold_right : 'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
val fold_left : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val unzip : ('a * 'b) t -> 'a t * 'b t
val unzip3 : ('a * 'b * 'c) t -> 'a t * 'b t * 'c t
val zip : 'a t -> 'b t -> ('a * 'b) t Or_unequal_lengths.t
val zip_exn : 'a t -> 'b t -> ('a * 'b) t
val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
val rev_mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
val reduce_balanced : 'a t -> f:('a -> 'a -> 'a) -> 'a option
val reduce_balanced_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
val group : 'a t -> break:('a -> 'a -> bool) -> 'a t t
val groupi : 'a t -> break:(int -> 'a -> 'a -> bool) -> 'a t t
val sort_and_group : 'a t -> compare:('a -> 'a -> int) -> 'a t t
val chunks_of : 'a t -> length:int -> 'a t t
val last : 'a t -> 'a option
val is_prefix : 'a t -> prefix:'a t -> equal:('a -> 'a -> bool) -> bool
val is_suffix : 'a t -> suffix:'a t -> equal:('a -> 'a -> bool) -> bool
val find_consecutive_duplicate : 'a t -> equal:('a -> 'a -> bool) -> ('a * 'a) option
val remove_consecutive_duplicates : ?which_to_keep:[ `First | `Last ] -> 'a t -> equal:('a -> 'a -> bool) -> 'a t
val dedup_and_sort : 'a t -> compare:('a -> 'a -> int) -> 'a t
val find_a_dup : 'a t -> compare:('a -> 'a -> int) -> 'a option
val contains_dup : 'a t -> compare:('a -> 'a -> int) -> bool
val find_all_dups : 'a t -> compare:('a -> 'a -> int) -> 'a list
val all_equal : 'a t -> equal:('a -> 'a -> bool) -> 'a option
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(int -> 'a -> bool) -> int
val range : ?stride:int -> ?start:[ `exclusive | `inclusive ] -> ?stop:[ `exclusive | `inclusive ] -> int -> int -> int t
val range' : compare:('a -> 'a -> int) -> stride:('a -> 'a) -> ?start:[ `exclusive | `inclusive ] -> ?stop:[ `exclusive | `inclusive ] -> 'a -> 'a -> 'a t
val init : int -> f:(int -> 'a) -> 'a t
val rev_filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val rev_filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
val filter_opt : 'a option t -> 'a t
module Assoc : sig ... end
val sub : 'a t -> pos:int -> len:int -> 'a t
val take : 'a t -> int -> 'a t
val drop : 'a t -> int -> 'a t
val take_while : 'a t -> f:('a -> bool) -> 'a t
val drop_while : 'a t -> f:('a -> bool) -> 'a t
val split_while : 'a t -> f:('a -> bool) -> 'a t * 'a t
val drop_last : 'a t -> 'a t option
val drop_last_exn : 'a t -> 'a t
val concat : 'a t t -> 'a t
val concat_no_order : 'a t t -> 'a t
val cons : 'a -> 'a t -> 'a t
val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
val permute : ?random_state:Base__.Random.State.t -> 'a t -> 'a t
val random_element : ?random_state:Base__.Random.State.t -> 'a t -> 'a option
val random_element_exn : ?random_state:Base__.Random.State.t -> 'a t -> 'a
val is_sorted : 'a t -> compare:('a -> 'a -> int) -> bool
val is_sorted_strictly : 'a t -> compare:('a -> 'a -> int) -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
module Infix : sig ... end
val transpose : 'a t t -> 'a t t option
val transpose_exn : 'a t t -> 'a t t
val intersperse : 'a t -> sep:'a -> 'a t
val split3 : ('a * 'b * 'c) list -> 'a list * 'b list * 'c list
val filter_map : f:('a -> 'b option) -> 'a list -> 'b list
val last_exn : 'a list -> 'a
val pp : f:('a -> string) -> 'a list -> string
val fold_left0 : ('a -> 'a -> 'a) -> 'a list -> 'a
val concat_map : f:('a -> 'b list) -> 'a list -> 'b list
val empty : 'a list -> bool
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