package ocsipersist-pgsql

You can search for identifiers within the package.

in-package search v0.2.0

ocsipersist-pgsql
- Ocsipersist
  - Functorial
    
    COLUMN
    
    Column
    
    Float
    
    Marshal
    
    C
    
    String
  - Lwt_thread
  - PGOCaml
  - Polymorphic
  - Ref
  - Store
ocsipersist-pgsql.settings
- Ocsipersist_settings

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Lwt end

type 'a t = 'a Lwt.t

type 'a u = 'a Lwt.u

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

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

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

val return : 'a -> 'a t

val fail : exn -> 'a t

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

val reraise : exn -> 'a

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

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

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

val dont_wait : (unit -> unit t) -> (exn -> unit) -> unit

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

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

val both : 'a t -> 'b t -> ('a * 'b) t

val join : unit t list -> unit t

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

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

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

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

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

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

exception Canceled

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

val cancel : 'a t -> unit

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

val protected : 'a t -> 'a t

val no_cancel : 'a t -> 'a t

val wrap_in_cancelable : 'a t -> 'a t

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

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 = Lwt.Infix

module Let_syntax = Lwt.Let_syntax

module Syntax = Lwt.Syntax

val return_unit : unit t

val return_none : 'a option t

val return_nil : 'a list t

val return_true : bool t

val return_false : bool t

val return_some : 'a -> 'a option t

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

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

val fail_with : string -> 'a t

val fail_invalid_arg : string -> 'a t

val of_result : ('a, exn) Stdlib.result -> 'a t

val wakeup_later_result : 'a u -> ('a, exn) Stdlib.result -> unit

type !'a state = 'a Lwt.state =

| Return of 'a
| Fail of exn
| Sleep

val state : 'a t -> 'a state

type 'a key = 'a Lwt.key

val new_key : unit -> 'a key

val get : 'a key -> 'a option

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

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

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

val wakeup_result : 'a u -> ('a, exn) Stdlib.result -> unit

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

deprecated Deprecated because Lwt_sequence is an implementation detail of Lwt. See https://github.com/ocsigen/lwt/issues/361

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

deprecated Deprecated because Lwt_sequence is an implementation detail of Lwt. See https://github.com/ocsigen/lwt/issues/361

val pause : unit -> unit t

val wakeup_paused : unit -> unit

val paused_count : unit -> int

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

val abandon_paused : unit -> unit

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 (>>=) : 'a t -> ('a -> 'b t) -> 'b t

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

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

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

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

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

val is_sleeping : 'a t -> bool

val ignore_result : 'a t -> unit

module Exception_filter = Lwt.Exception_filter

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_finalize : 
  (exn -> exn) ->
  (unit -> 'a t) ->
  (unit -> unit t) ->
  'a t

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

val abandon_wakeups : unit -> unit

val debug_state_is : 'a state -> 'a t -> bool t

val close_in : 'a Lwt_io.channel -> unit Lwt.t

val really_input : Lwt_io.input_channel -> bytes -> int -> int -> unit Lwt.t

val input_binary_int : Lwt_io.input_channel -> int Lwt.t

val input_char : Lwt_io.input_channel -> char Lwt.t

val output_string : Lwt_io.output_channel -> string -> unit Lwt.t

val output_binary_int : Lwt_io.output_channel -> int -> unit Lwt.t

val output_char : Lwt_io.output_channel -> char -> unit Lwt.t

val flush : Lwt_io.output_channel -> unit Lwt.t

val open_connection : 
  Unix.sockaddr ->
  (Lwt_io.input_channel * Lwt_io.output_channel) Lwt.t

type out_channel = Lwt_io.output_channel

type in_channel = Lwt_io.input_channel