`type lock`

The light-weight type of a lock, i.e. a construction which may be used to guarantee that a section will not be interrupted by another thread.

This light-weight type is independent of the underlying locking mechanism and can be used if you do not know whether your code will run with vmthreads, Posix threads, coThreads, etc.

`val create : enter:(unit -> unit) -> leave:(unit -> unit) -> lock`

Create a lock from a pair of locking/unlocking functions

- parameter enter

  Enter critical section.

- parameter leave

  Leave critical section. .

`val nolock : lock`

A lock which does nothing.

`val synchronize : (unit -> lock) -> ('a -> 'b) -> 'a -> 'b`

`synchronize locker f` returns a function `f'` which behaves as `f` but whose executions are protected by one lock obtained from `locker`. The same lock will be reused for all subsequent uses of `f'`.

For instance, `synchronize Mutex.make f` is a new function whose executions will by synchronized by a new lock. Conversely, `synchronize (const my_lock) f` is a new function whose executions will be synchronized by an existing lock `my_lock`.

`val sync : lock -> ('a -> 'b) -> 'a -> 'b`

Specialized version of `synchronized`.

`sync lock f` behaves as `synchronize (const lock) f` but slightly faster

`val compose : lock -> lock -> lock`

Compose two lock systems into a third lock system.

`module type BaseLock = sig ... end`

A signature for modules which implement locking.

`module type Lock = sig ... end`
`module MakeLock (M : BaseLock) : Lock with type t = M.t`
`module NoLock : Lock`