package sqlexpr

You can search for identifiers within the package.

in-package search v0.2.0

package sqlexpr

sqlexpr
- Sqlexpr_concurrency
  - Id
  - Lwt
  - THREAD
  - THREAD_LOCAL_STATE
- Sqlexpr_sqlite
  - Make
    
    Conversion
    
    Directives
    
    M
  - Make_gen
    
    Conversion
    
    Directives
    
    M
    
    P
    
    TLS
  - POOL
    
    TLS
  - S
    
    Conversion
    
    Directives
- Sqlexpr_sqlite_lwt
  - Conversion
  - Directives
- Sqlexpr_utils
  - List
  - Option

Legend:
Library
Module
Module type
Parameter
Class
Class type

type 'a t

val return : 'a -> 'a t

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

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

val fail : exn -> 'a t

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

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

val sleep : float -> unit t

val auto_yield : float -> unit -> unit 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

type mutex

val create_recursive_mutex : unit -> mutex

Create a recursive mutex that can be locked recursively by the same * thread; i.e., unlike a regular mutex, * with_lock m (fun () -> ... with_lock m (fun () -> ... )) * will not block.

val with_lock : mutex -> (unit -> 'a t) -> 'a t

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

include Sqlexpr_concurrency.THREAD_LOCAL_STATE
  with type 'a t := 'a t
  with type 'a key = 'a Lwt.key

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 t) -> 'b t