package hack_parallel

  1. Overview
  2. Docs
package hack_parallel
Legend:
Library
Module
Module type
Parameter
Class
Class type
module UnlabeledList = List
module List = StdLabels.List
module String = StdLabels.String
val invalid_argf : ('a, unit, string, unit -> 'b) format4 -> 'a
module T : sig ... end
include module type of struct include T end
type 'a t = 'a list
val of_list : 'a -> 'a
val range : ?stride:int -> ?start:[< `exclusive | `inclusive inclusive ] -> ?stop:[< `exclusive | `inclusive exclusive ] -> int -> int -> int list
val length : 'a list -> int
val hd_exn : 'a list -> 'a
val tl_exn : 'a list -> 'a list
val hd : 'a list -> 'a option
val tl : 'a list -> 'a list option
val nth : 'a list -> int -> 'a option
val nth_exn : 'a list -> int -> 'a
val rev_append : 'a list -> 'a list -> 'a list
val rev : 'a list -> 'a list
val unordered_append : 'a list -> 'a list -> 'a list
val rev_map : 'a list -> f:('a -> 'b) -> 'b list
exception Length_mismatch of string * int * int
val check_length2 : string -> 'a list -> 'b list -> unit
val check_length3 : string -> 'a list -> 'b list -> 'c list -> unit
val iter2_exn : 'a list -> 'b list -> f:('a -> 'b -> unit) -> unit
val rev_map2_exn : 'a list -> 'b list -> f:('a -> 'b -> 'c) -> 'c list
val fold2_exn : 'a list -> 'b list -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
val for_all2_exn : 'a list -> 'b list -> f:('a -> 'b -> bool) -> bool
val exists2_exn : 'a list -> 'b list -> f:('a -> 'b -> bool) -> bool
val mem : ?equal:('a -> 'a -> bool) -> 'a list -> 'a -> bool
val assq : 'a -> ('a * 'b) list -> 'b
val rev_filter : 'a list -> f:('a -> bool) -> 'a list
val filter : 'a list -> f:('a -> bool) -> 'a list
val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val find_map : 'a list -> f:('a -> 'b option) -> 'b option
val find : 'a list -> f:('a -> bool) -> 'a option
val find_exn : 'a list -> f:('a -> bool) -> 'a
val findi : 'a list -> f:(int -> 'a -> bool) -> (int * 'a) option
val exists : 'a list -> f:('a -> bool) -> bool

changing the order of arguments on some standard List functions.

val for_all : 'a list -> f:('a -> bool) -> bool
val iter : 'a list -> f:('a -> unit) -> unit
val fold : 'a list -> init:'b -> f:('b -> 'a -> 'b) -> 'b

For the container interface.

val fold_left : 'a list -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val to_array : 'a list -> 'a array
val to_list : 'a -> 'a

Tail recursive versions of standard List module

val slow_append : 'a list -> 'a list -> 'a list
val count_append : 'a list -> 'a list -> int -> 'a list
val append : 'a list -> 'a list -> 'a list
val map_slow : 'a list -> f:('a -> 'b) -> 'b list
val count_map : f:('a -> 'b) -> 'a list -> int -> 'b list
val map : 'a list -> f:('a -> 'b) -> 'b list
val (>>|) : 'a list -> ('a -> 'b) -> 'b list
val map2_exn : 'a list -> 'b list -> f:('a -> 'b -> 'c) -> 'c list
val rev_map3_exn : 'a list -> 'b list -> 'c list -> f:('a -> 'b -> 'c -> 'd) -> 'd list
val map3_exn : 'a list -> 'b list -> 'c list -> f:('a -> 'b -> 'c -> 'd) -> 'd list
val rev_map_append : 'a list -> 'b list -> f:('a -> 'b) -> 'b list
val fold_right : 'a list -> f:('a -> 'b -> 'b) -> init:'b -> 'b
val unzip : ('a * 'b) list -> 'a list * 'b list
val zip_exn : 'a list -> 'b list -> ('a * 'b) list
val zip : 'a list -> 'b list -> ('a * 'b) list option

Additional list operations

val rev_mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b list
val mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b list
val iteri : 'a list -> f:(int -> 'a -> 'b) -> unit
val foldi : 'a list -> f:(int -> 'b -> 'a -> 'b) -> init:'b -> 'b
val filteri : 'a list -> f:(int -> 'a -> bool) -> 'a list
val reduce : 'a list -> f:('a -> 'a -> 'a) -> 'a option
val reduce_exn : 'a list -> f:('a -> 'a -> 'a) -> 'a
val groupi : 'a list -> break:(int -> 'a -> 'a -> bool) -> 'a list list
val group : 'a list -> break:('a -> 'a -> bool) -> 'a list list
val concat_map : 'a list -> f:('a -> 'b list) -> 'b list
val concat_mapi : 'a list -> f:(int -> 'a -> 'b list) -> 'b list
val merge : 'a list -> 'a list -> cmp:('a -> 'a -> int) -> 'a list
include sig ... end
module Monad : sig ... end
module Monad_infix = Monad.Monad_infix
val ignore : 'a list -> unit list
val join : 'a list list -> 'a list
val bind : 'a list -> ('a -> 'b list) -> 'b list
val (>>=) : 'a list -> ('a -> 'b list) -> 'b list
val return : 'a -> 'a list
val all : 'a list list -> 'a list list
val all_ignore : unit list list -> unit list
val last_exn : 'a list -> 'a

returns final element of list

val last : 'a list -> 'a option

optionally returns final element of list

val find_consecutive_duplicate : 'a list -> equal:('a -> 'a -> bool) -> ('a * 'a) option
val remove_consecutive_duplicates : 'a list -> equal:('a -> 'a -> bool) -> 'a list
val dedup : ?compare:('a -> 'a -> int) -> 'a list -> 'a list

returns sorted version of list with duplicates removed

val contains_dup : ?compare:('a -> 'a -> int) -> 'a list -> bool
val find_a_dup : ?compare:('a -> 'a -> int) -> 'a list -> 'a option
val count : 'a list -> f:('a -> bool) -> int
val sum : (module Hack_commutative_group.S with type t = 'a) -> 'b list -> f:('b -> 'a) -> 'a
val min_elt : 'a list -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a list -> cmp:('a -> 'a -> int) -> 'a option
val init : int -> f:(int -> 'a) -> 'a list
val rev_filter_map : 'a list -> f:('a -> 'b option) -> 'b list
val filter_map : 'a list -> f:('a -> 'b option) -> 'b list
val rev_filter_mapi : 'a list -> f:(int -> 'a -> 'b option) -> 'b list
val filter_mapi : 'a list -> f:(int -> 'a -> 'b option) -> 'b list
val filter_opt : 'a option list -> 'a list
val partition_map : 'a list -> f:('a -> [< `Fst of 'b | `Snd of 'c ]) -> 'b list * 'c list
val partition_tf : 'a list -> f:('a -> bool) -> 'a list * 'a list
module Assoc : sig ... end
val sub : 'a list -> pos:int -> len:int -> 'a list
val split_n : 'a list -> int -> 'a list * 'a list
val take : 'a list -> int -> 'a list
val drop : 'a list -> int -> 'a list
val split_while : 'a list -> f:('a -> bool) -> 'a list * 'a list
val take_while : 'a list -> f:('a -> bool) -> 'a list
val drop_while : 'a list -> f:('a -> bool) -> 'a list
val cartesian_product : 'a list -> 'b list -> ('a * 'b) list
val concat : 'a list list -> 'a list
val concat_no_order : 'a list list -> 'a list
val cons : 'a -> 'a list -> 'a list
val is_empty : 'a list -> bool
val is_sorted : 'a list -> compare:('a -> 'a -> int) -> bool
val is_sorted_strictly : 'a list -> compare:('a -> 'a -> int) -> bool
module Infix : sig ... end
val compare : 'a list -> 'b list -> cmp:('a -> 'b -> int) -> int
val equal : 'a list -> 'b list -> equal:('a -> 'b -> bool) -> bool
val transpose : 'a list list -> 'a list list option
exception Transpose_got_lists_of_different_lengths of int list
val transpose_exn : 'a list list -> 'a list list
val intersperse : 'a list -> sep:'a -> 'a list
val replicate : num:int -> 'a -> 'a list
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