macaque_lwt 0.1 (latest) · OCaml Package

type +'a t

val return : 'a -> 'a t

val fail : exn -> 'a t

val fail_with : string -> 'a t

val fail_invalid_arg : string -> 'a t

val bind : 'a t -> ('a -> 'b t) -> 'b t

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

val (=<<) : ('a -> 'b t) -> 'a t -> 'b t

val map : ('a -> 'b) -> 'a t -> 'b t

val (>|=) : 'a t -> ('a -> 'b) -> 'b t

val (=|<) : ('a -> 'b) -> 'a t -> 'b t

val return_unit : unit t

val return_none : 'a option t

val return_some : 'a -> 'a option t

val return_nil : 'a list t

val return_true : bool t

val return_false : bool t

val return_ok : 'a -> ('a, 'b) Result.result t

val return_error : 'e -> ('a, 'e) Result.result t

type 'a key

val new_key : unit -> 'a key

val get : 'a key -> 'a option

val with_value : 'a key -> 'a option -> (unit -> 'b) -> 'b

val catch : (unit -> 'a t) -> (exn -> 'a t) -> 'a t

val try_bind : (unit -> 'a t) -> ('a -> 'b t) -> (exn -> 'b t) -> 'b t

val finalize : (unit -> 'a t) -> (unit -> unit t) -> 'a t

val wrap : (unit -> 'a) -> 'a t

val wrap1 : ('a -> 'b) -> 'a -> 'b t

val wrap2 : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c t

val wrap3 : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> 'd t

val wrap4 : ('a -> 'b -> 'c -> 'd -> 'e) -> 'a -> 'b -> 'c -> 'd -> 'e t

val wrap5 : 
  ('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
  'a ->
  'b ->
  'c ->
  'd ->
  'e ->
  'f t

val wrap6 : 
  ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) ->
  'a ->
  'b ->
  'c ->
  'd ->
  'e ->
  'f ->
  'g t

val wrap7 : 
  ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g -> 'h) ->
  'a ->
  'b ->
  'c ->
  'd ->
  'e ->
  'f ->
  'g ->
  'h t

val choose : 'a t list -> 'a t

val nchoose : 'a t list -> 'a list t

val nchoose_split : 'a t list -> ('a list * 'a t list) t

val join : unit t list -> unit t

val (<?>) : 'a t -> 'a t -> 'a t

val (<&>) : unit t -> unit t -> unit t

val async : (unit -> 'a t) -> unit

val ignore_result : 'a t -> unit

val async_exception_hook : (exn -> unit) Pervasives.ref

type 'a u

val wait : unit -> 'a t * 'a u

val wakeup : 'a u -> 'a -> unit

val wakeup_exn : 'a u -> exn -> unit

val wakeup_later : 'a u -> 'a -> unit

val wakeup_later_exn : 'a u -> exn -> unit

val waiter_of_wakener : 'a u -> 'a t

type !'a result = ('a, exn) Result.result

val make_value : 'a -> 'a result

deprecated Use Result.Ok, which is the same as Ok since OCaml 4.03.

val make_error : exn -> 'a result

deprecated Use Result.Error, which is the same as Error since OCaml 4.03.

val of_result : 'a result -> 'a t

val wakeup_result : 'a u -> 'a result -> unit

val wakeup_later_result : 'a u -> 'a result -> unit

type !'a state =

| Return of 'a
| Fail of exn
| Sleep

val state : 'a t -> 'a state

val is_sleeping : 'a t -> bool

exception Canceled

val task : unit -> 'a t * 'a u

val on_cancel : 'a t -> (unit -> unit) -> unit

val add_task_r : 'a u Lwt_sequence.t -> 'a t

val add_task_l : 'a u Lwt_sequence.t -> 'a t

val cancel : 'a t -> unit

val pick : 'a t list -> 'a t

val npick : 'a t list -> 'a list t

val protected : 'a t -> 'a t

val no_cancel : 'a t -> 'a t

val pause : unit -> unit t

val wakeup_paused : unit -> unit

val paused_count : unit -> int

val register_pause_notifier : (int -> unit) -> unit

val on_success : 'a t -> ('a -> unit) -> unit

val on_failure : 'a t -> (exn -> unit) -> unit

val on_termination : 'a t -> (unit -> unit) -> unit

val on_any : 'a t -> ('a -> unit) -> (exn -> unit) -> unit

module Infix : sig ... end

val poll : 'a t -> 'a option

val apply : ('a -> 'b t) -> 'a -> 'b t

val backtrace_bind : (exn -> exn) -> 'a t -> ('a -> 'b t) -> 'b t

val backtrace_catch : (exn -> exn) -> (unit -> 'a t) -> (exn -> 'a t) -> 'a t

val backtrace_try_bind : 
  (exn -> exn) ->
  (unit -> 'a t) ->
  ('a -> 'b t) ->
  (exn -> 'b t) ->
  'b t

val backtrace_finalize : 
  (exn -> exn) ->
  (unit -> 'a t) ->
  (unit -> unit t) ->
  'a t

val abandon_wakeups : unit -> unit

type in_channel = Lwt_io.input_channel

val in_channel_of_descr : Lwt_unix.file_descr -> in_channel

val make_in_channel : 
  ?close:(unit -> unit Lwt.t) ->
  (bytes -> int -> int -> int Lwt.t) ->
  in_channel

val input_line : in_channel -> string Lwt.t

val input_value : in_channel -> 'a Lwt.t

val input : in_channel -> bytes -> int -> int -> int Lwt.t

val really_input : in_channel -> bytes -> int -> int -> unit Lwt.t

val input_char : in_channel -> char Lwt.t

val input_binary_int : in_channel -> int Lwt.t

val open_in_gen : Unix.open_flag list -> int -> string -> in_channel Lwt.t

val open_in : string -> in_channel Lwt.t

val close_in : in_channel -> unit Lwt.t

type out_channel = Lwt_io.output_channel

val out_channel_of_descr : Lwt_unix.file_descr -> out_channel

val make_out_channel : 
  ?close:(unit -> unit Lwt.t) ->
  (bytes -> int -> int -> int Lwt.t) ->
  out_channel

val output : out_channel -> bytes -> int -> int -> unit Lwt.t

val flush : out_channel -> unit Lwt.t

val output_string : out_channel -> string -> unit Lwt.t

val output_value : out_channel -> 'a -> unit Lwt.t

val output_char : out_channel -> char -> unit Lwt.t

val output_binary_int : out_channel -> int -> unit Lwt.t

val open_out_gen : Unix.open_flag list -> int -> string -> out_channel Lwt.t

val open_out : string -> out_channel Lwt.t

val close_out : out_channel -> unit Lwt.t

val open_connection : Unix.sockaddr -> (in_channel * out_channel) Lwt.t

package macaque_lwt