def IO.BaseMutex : Type

Mutual exclusion primitive (a lock).

If you want to guard shared state, use Mutex α instead.

Equations

• IO.BaseMutex = NonemptyType.type IO.BaseMutexImpl

instance IO.instNonemptyBaseMutex : Nonempty IO.BaseMutex

Equations

• IO.instNonemptyBaseMutex = IO.instNonemptyBaseMutex.proof_1

@[extern lean_io_basemutex_new]

opaque IO.BaseMutex.new : BaseIO IO.BaseMutex

Creates a new BaseMutex.

@[extern lean_io_basemutex_lock]

opaque IO.BaseMutex.lock (mutex : IO.BaseMutex) : BaseIO Unit

Locks a BaseMutex. Waits until no other thread has locked the mutex.

The current thread must not have already locked the mutex. Reentrant locking is undefined behavior (inherited from the C++ implementation).

@[extern lean_io_basemutex_unlock]

opaque IO.BaseMutex.unlock (mutex : IO.BaseMutex) : BaseIO Unit

Unlocks a BaseMutex.

The current thread must have already locked the mutex. Unlocking an unlocked mutex is undefined behavior (inherited from the C++ implementation).

def IO.Condvar : Type

Condition variable.

Equations

• IO.Condvar = NonemptyType.type IO.CondvarImpl

instance IO.instNonemptyCondvar : Nonempty IO.Condvar

Equations

• IO.instNonemptyCondvar = IO.instNonemptyCondvar.proof_1

@[extern lean_io_condvar_new]

opaque IO.Condvar.new : BaseIO IO.Condvar

Creates a new condition variable.

@[extern lean_io_condvar_wait]

opaque IO.Condvar.wait (condvar : IO.Condvar) (mutex : IO.BaseMutex) : BaseIO Unit

Waits until another thread calls notifyOne or notifyAll.

@[extern lean_io_condvar_notify_one]

opaque IO.Condvar.notifyOne (condvar : IO.Condvar) : BaseIO Unit

Wakes up a single other thread executing wait.

@[extern lean_io_condvar_notify_all]

opaque IO.Condvar.notifyAll (condvar : IO.Condvar) : BaseIO Unit

Wakes up all other threads executing wait.

def IO.Condvar.waitUntil {m : Type → Type u_1} [inst : Monad m] [inst : MonadLift BaseIO m] (condvar : IO.Condvar) (mutex : IO.BaseMutex) (pred : m Bool) : m Unit

Waits on the condition variable until the predicate is true.

Equations

• One or more equations did not get rendered due to their size.

structure IO.Mutex (α : Type) : Type

• ref : IO.Ref α
• mutex : IO.BaseMutex

Mutual exclusion primitive (lock) guarding shared state of type α.

The type Mutex α is similar to IO.Ref α, except that concurrent accesses are guarded by a mutex instead of atomic pointer operations and busy-waiting.

instance IO.instNonemptyMutex : ∀ {α : Type} [inst : Nonempty α], Nonempty (IO.Mutex α)

Equations

• @IO.instNonemptyMutex = @IO.instNonemptyMutex.proof_1

instance IO.instCoeOutMutexBaseMutex {α : Type} : CoeOut (IO.Mutex α) IO.BaseMutex

Equations

• IO.instCoeOutMutexBaseMutex = { coe := IO.Mutex.mutex }

def IO.Mutex.new {α : Type} (a : α) : BaseIO (IO.Mutex α)

Creates a new mutex.

Equations

• IO.Mutex.new a = do let __do_lift ← IO.mkRef a let __do_lift_1 ← IO.BaseMutex.new pure { ref := __do_lift, mutex := __do_lift_1 }

@[inline]

abbrev IO.AtomicT (σ : Type) (m : Type → Type) (α : Type) : Type

AtomicT α m is the monad that can be atomically executed inside a Mutex α, with outside monad m. The action has access to the state α of the mutex (via get and set).

Equations

• IO.AtomicT = StateRefT' IO.RealWorld

def IO.Mutex.atomically {m : Type → Type} {α : Type} {β : Type} [inst : Monad m] [inst : MonadLiftT BaseIO m] [inst : MonadFinally m] (mutex : IO.Mutex α) (k : IO.AtomicT α m β) : m β

mutex.atomically k runs k with access to the mutex's state while locking the mutex.

Equations

• IO.Mutex.atomically mutex k = tryFinally (do liftM (IO.BaseMutex.lock mutex.mutex) k mutex.ref) (liftM (IO.BaseMutex.unlock mutex.mutex))

def IO.Mutex.atomicallyOnce {m : Type → Type} {α : Type} {β : Type} [inst : Monad m] [inst : MonadLiftT BaseIO m] [inst : MonadFinally m] (mutex : IO.Mutex α) (condvar : IO.Condvar) (pred : IO.AtomicT α m Bool) (k : IO.AtomicT α m β) : m β

mutex.atomicallyOnce condvar pred k runs k, waiting on condvar until pred returns true. Both k and pred have access to the mutex's state.

Equations

• IO.Mutex.atomicallyOnce mutex condvar pred k = let x := { monadLift := fun {α} => liftM }; IO.Mutex.atomically mutex do IO.Condvar.waitUntil condvar mutex.mutex pred k