Struct SharedCell 

pub struct SharedCell { /* private fields */ }

The storage a Shared<T> value addresses.

Cloning the Arc is what “crosses by sharing” means: every task that received the Shared addresses this one cell, and the Mutex is what makes their accesses take turns.

Implementations

impl SharedCell

pub fn new(value: Transfer) -> Arc<SharedCell>

Wraps an already converted value.

pub fn wrap(value: &Value, span: Span) -> Result<Arc<SharedCell>, RuntimeError>

Shared(value): wraps value, or reports why it may not be wrapped.

The payload must be task-safe for the same reason a spawned closure’s captures must be. A Shared<Vector<T>> would let a vector be reached from two tasks, which is exactly what the sentence naming Shared forbids.

pub fn lock<R>( &self, span: Span, body: impl FnOnce(Value) -> Result<(R, Value), RuntimeError>, ) -> Result<R, RuntimeError>

Runs body with the wrapped value, holding the lock for the whole call, and stores back whatever body leaves in it.

body receives the value and returns its own result together with the value to store — which is the same value when the closure took it as a var alias and mutated it in place. A body that raises an error stores nothing, so a half-finished modification is never left behind for another task to find.

Trait Implementations

impl Debug for SharedCell

A cell is a handle, and its contents are reachable only under the lock, so it shows as the handle it is rather than as what it currently holds.

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

Formats the value using the given formatter.