package hack_parallel

  1. Overview
  2. Docs
package hack_parallel
Legend:
Library
Module
Module type
Parameter
Class
Class type
module Arg = Stdlib.Arg
module Array = Stdlib.Array
module ArrayLabels = Stdlib.ArrayLabels
module Buffer = Stdlib.Buffer
module Callback = Stdlib.Callback
module Char = Stdlib.Char
module Complex = Stdlib.Complex
module Digest = Stdlib.Digest
module Filename = Stdlib.Filename
module Format = Stdlib.Format
module Gc = Stdlib.Gc
module Genlex = Stdlib.Genlex
module Hashtbl = Stdlib.Hashtbl
module Int32 = Stdlib.Int32
module Int64 = Stdlib.Int64
module Lazy = Stdlib.Lazy
module Lexing = Stdlib.Lexing
module List = Stdlib.List
module ListLabels = Stdlib.ListLabels
module Map = Stdlib.Map
module Marshal = Stdlib.Marshal
module MoreLabels = Stdlib.MoreLabels
module Nativeint = Stdlib.Nativeint
module Oo = Stdlib.Oo
module Parsing = Stdlib.Parsing
module Pervasives = Stdlib.Pervasives
module Printexc = Stdlib.Printexc
module Printf = Stdlib.Printf
module Queue = Stdlib.Queue
module Random = Stdlib.Random
module Scanf = Stdlib.Scanf
module Set = Stdlib.Set
module Sort = Sort
module Stack = Stdlib.Stack
module StdLabels = Stdlib.StdLabels
module Stream = Stdlib.Stream
module String = Stdlib.String
module StringLabels = Stdlib.StringLabels
module Sys = Stdlib.Sys
module Weak = Stdlib.Weak
include module type of struct include Pervasives end
val raise : exn -> 'a
val raise_notrace : exn -> 'a
val invalid_arg : string -> 'a
val failwith : string -> 'a
exception Exit
val (=) : 'a -> 'a -> bool
val (<>) : 'a -> 'a -> bool
val (<) : 'a -> 'a -> bool
val (>) : 'a -> 'a -> bool
val (<=) : 'a -> 'a -> bool
val (>=) : 'a -> 'a -> bool
val compare : 'a -> 'a -> int
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
  • deprecated Use (&&) instead.
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
  • deprecated Use (||) instead.
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (|>) : 'a -> ('a -> 'b) -> 'b
val (@@) : ('a -> 'b) -> 'a -> 'b
val (~-) : int -> int
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val max_int : int
val min_int : int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val lnot : int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (asr) : int -> int -> int
val (~-.) : float -> float
val (~+.) : float -> float
val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val infinity : float
val neg_infinity : float
val nan : float
val max_float : float
val min_float : float
val epsilon_float : float
type nonrec fpclass = Stdlib.fpclass =
  1. | FP_normal
  2. | FP_subnormal
  3. | FP_zero
  4. | FP_infinite
  5. | FP_nan
val classify_float : float -> fpclass
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val ignore : 'a -> unit
val string_of_bool : bool -> string
val bool_of_string : string -> bool
val bool_of_string_opt : string -> bool option
val string_of_int : int -> string
val int_of_string : string -> int
val int_of_string_opt : string -> int option
val string_of_float : float -> string
val float_of_string : string -> float
val float_of_string_opt : string -> float option
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
val (@) : 'a list -> 'a list -> 'a list
type nonrec in_channel = Stdlib.in_channel
type nonrec out_channel = Stdlib.out_channel
val stdin : Stdlib.in_channel
val stdout : Stdlib.out_channel
val stderr : Stdlib.out_channel
val print_char : char -> unit
val print_string : string -> unit
val print_bytes : bytes -> unit
val print_int : int -> unit
val print_float : float -> unit
val print_endline : string -> unit
val print_newline : unit -> unit
val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_bytes : bytes -> unit
val prerr_int : int -> unit
val prerr_float : float -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
val read_line : unit -> string
val read_int : unit -> int
val read_int_opt : unit -> int option
val read_float : unit -> float
val read_float_opt : unit -> float option
type nonrec open_flag = Stdlib.open_flag =
  1. | Open_rdonly
  2. | Open_wronly
  3. | Open_append
  4. | Open_creat
  5. | Open_trunc
  6. | Open_excl
  7. | Open_binary
  8. | Open_text
  9. | Open_nonblock
val open_out : string -> Stdlib.out_channel
val open_out_bin : string -> Stdlib.out_channel
val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel
val flush : Stdlib.out_channel -> unit
val flush_all : unit -> unit
val output_char : Stdlib.out_channel -> char -> unit
val output_string : Stdlib.out_channel -> string -> unit
val output_bytes : Stdlib.out_channel -> bytes -> unit
val output : Stdlib.out_channel -> bytes -> int -> int -> unit
val output_substring : Stdlib.out_channel -> string -> int -> int -> unit
val output_byte : Stdlib.out_channel -> int -> unit
val output_binary_int : Stdlib.out_channel -> int -> unit
val output_value : Stdlib.out_channel -> 'a -> unit
val seek_out : Stdlib.out_channel -> int -> unit
val pos_out : Stdlib.out_channel -> int
val out_channel_length : Stdlib.out_channel -> int
val close_out : Stdlib.out_channel -> unit
val close_out_noerr : Stdlib.out_channel -> unit
val set_binary_mode_out : Stdlib.out_channel -> bool -> unit
val open_in : string -> Stdlib.in_channel
val open_in_bin : string -> Stdlib.in_channel
val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel
val input_char : Stdlib.in_channel -> char
val input_line : Stdlib.in_channel -> string
val input : Stdlib.in_channel -> bytes -> int -> int -> int
val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit
val really_input_string : Stdlib.in_channel -> int -> string
val input_byte : Stdlib.in_channel -> int
val input_binary_int : Stdlib.in_channel -> int
val input_value : Stdlib.in_channel -> 'a
val seek_in : Stdlib.in_channel -> int -> unit
val pos_in : Stdlib.in_channel -> int
val in_channel_length : Stdlib.in_channel -> int
val close_in : Stdlib.in_channel -> unit
val close_in_noerr : Stdlib.in_channel -> unit
val set_binary_mode_in : Stdlib.in_channel -> bool -> unit
module LargeFile = Stdlib.LargeFile
type nonrec !'a ref = 'a Stdlib.ref = {
  1. mutable contents : 'a;
}
val ref : 'a -> 'a ref
val (!) : 'a ref -> 'a
val (:=) : 'a ref -> 'a -> unit
val incr : int ref -> unit
val decr : int ref -> unit
type nonrec (!'a, !'b) result = ('a, 'b) Stdlib.result =
  1. | Ok of 'a
  2. | Error of 'b
type (!'a, !'b, !'c, !'d, !'e, !'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6
type (!'a, !'b, !'c, !'d) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
type (!'a, !'b, !'c) format = ('a, 'b, 'c, 'c) format4
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6
val exit : int -> 'a
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
val do_at_exit : unit -> unit
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