Struct MutexData 

pub struct MutexData { /* private fields */ }

Mutex<T> storage — a single typed payload protected by a Rust Mutex so concurrent Arc<MutexData> shares observe each other’s mutations (the canonical “shared cell with exclusion” shape, mirror of ChannelData’s Mutex<ChannelInner> interior-mutability shape).

At landing the VM is single-threaded so lock() / try_lock() are no-op markers — the contract they preserve is “the inner value is mutated under exclusion” (the same contract user code reasons about). When the VM grows real concurrency, the same Mutex here will serialize concurrent lock() calls without API churn.

The inner Option<KindedSlot> carries one strong-count share for the wrapped value when present; take() / replace() discipline preserves the share-discipline across set(...) (the old slot drops, the new slot is owned by the cell).

Implementations

impl MutexData

pub fn new(value: KindedSlot) -> Self

Build a MutexData wrapping value.

pub fn lock(&self)

lock() — at landing a no-op marker (single-threaded VM). When the runtime grows real concurrency, this is the acquire point for the inner std::sync::Mutex.

pub fn try_lock(&self) -> bool

try_lock() — at landing always returns true (single-threaded VM; there’s no contention to fail). Mirror of lock().

pub fn get(&self) -> KindedSlot

Read the current value (clone of the inner KindedSlot). KindedSlot::Clone bumps the inner share so the returned slot is independently owned.

pub fn set(&self, new_value: KindedSlot)

Replace the wrapped value. The prior slot drops here (KindedSlot::Drop retires its inner share); the new slot is owned by the cell.

Trait Implementations

impl Debug for MutexData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.