Struct AsyncLockKp

Source

pub struct AsyncLockKp<R, Lock, Mid, V, Root, LockValue, MidValue, Value, MutRoot, MutLock, MutMid, MutValue, G1, S1, L, G2, S2>where
    Root: Borrow<R>,
    LockValue: Borrow<Lock>,
    MidValue: Borrow<Mid>,
    Value: Borrow<V>,
    MutRoot: BorrowMut<R>,
    MutLock: BorrowMut<Lock>,
    MutMid: BorrowMut<Mid>,
    MutValue: BorrowMut<V>,
    G1: Fn(Root) -> Option<LockValue> + Clone,
    S1: Fn(MutRoot) -> Option<MutLock> + Clone,
    L: AsyncLockLike<Lock, MidValue> + AsyncLockLike<Lock, MutMid> + Clone,
    G2: Fn(MidValue) -> Option<Value> + Clone,
    S2: Fn(MutMid) -> Option<MutValue> + Clone,
{ /* private fields */ }

Expand description

An async keypath that handles async locked values (e.g., Arc<tokio::sync::Mutex>)

Structure:

prev: Keypath from Root to Lock container (e.g., Arc<tokio::sync::Mutex>)
mid: Async lock access handler that goes from Lock to Inner value
next: Keypath from Inner value to final Value

§Type Parameters

R: Root type (base)
Lock: Lock container type (e.g., Arc<tokio::sync::Mutex>)
Mid: The type inside the lock
V: Final value type
Rest are the same generic parameters as Kp

§Cloning Behavior

IMPORTANT: All Clone operations in this struct are SHALLOW clones:

AsyncLockKp itself derives Clone - this clones the three field references/closures
prev and next fields are Kp structs containing function pointers (cheap to clone)
mid field implements AsyncLockLike trait - typically just PhantomData (zero-cost clone)
When Lock: Clone (e.g., Arc<tokio::sync::Mutex<T>>), cloning is just incrementing reference count
NO deep data cloning occurs - all clones are pointer/reference increments

Implementations§

Source §

impl<R, Lock, Mid, V, Root, LockValue, MidValue, Value, MutRoot, MutLock, MutMid, MutValue, G1, S1, L, G2, S2> AsyncLockKp<R, Lock, Mid, V, Root, LockValue, MidValue, Value, MutRoot, MutLock, MutMid, MutValue, G1, S1, L, G2, S2>
where Root: Borrow<R>, LockValue: Borrow<Lock>, MidValue: Borrow<Mid>, Value: Borrow<V>, MutRoot: BorrowMut<R>, MutLock: BorrowMut<Lock>, MutMid: BorrowMut<Mid>, MutValue: BorrowMut<V>, G1: Fn(Root) -> Option<LockValue> + Clone, S1: Fn(MutRoot) -> Option<MutLock> + Clone, L: AsyncLockLike<Lock, MidValue> + AsyncLockLike<Lock, MutMid> + Clone, G2: Fn(MidValue) -> Option<Value> + Clone, S2: Fn(MutMid) -> Option<MutValue> + Clone,

Source

pub fn new( prev: Kp<R, Lock, Root, LockValue, MutRoot, MutLock, G1, S1>, mid: L, next: Kp<Mid, V, MidValue, Value, MutMid, MutValue, G2, S2>, ) -> Self

Create a new AsyncLockKp with prev, mid, and next components

Source

pub async fn get(&self, root: Root) -> Option<Value>
where Lock: Clone,

Get the value through the lock

This will:

Use prev to get to the Lock
Use mid to asynchronously lock and get the Inner value
Use next to get to the final Value

§SHALLOW CLONING NOTE

When lock is cloned (e.g., Arc<tokio::sync::Mutex<T>>):

Only the Arc reference count is incremented (one atomic operation)
The actual data T inside the Mutex is NEVER cloned
This is safe and efficient - the whole point of Arc

Source

pub async fn get_mut(&self, root: MutRoot) -> Option<MutValue>
where Lock: Clone,

Get mutable access to the value through the lock

Source

pub async fn set<F>(&self, root: Root, updater: F) -> Result<(), String>
where Lock: Clone, F: FnOnce(&mut V),

Set the value through the lock using an updater function.

Uses interior mutability—no mutable root required. RwLock/Mutex allow mutation through &self (lock().write() etc.), so root can be &Root.

Internally uses: prev.get → mid.lock_read/lock_write → next.set (the setter path).

Source

pub fn then<V2, Value2, MutValue2, G3, S3>( self, next_kp: Kp<V, V2, Value, Value2, MutValue, MutValue2, G3, S3>, ) -> AsyncLockKp<R, Lock, Mid, V2, Root, LockValue, MidValue, Value2, MutRoot, MutLock, MutMid, MutValue2, G1, S1, L, impl Fn(MidValue) -> Option<Value2> + Clone + use<G1, G2, G3, L, Lock, LockValue, Mid, MidValue, MutLock, MutMid, MutRoot, MutValue, MutValue2, R, Root, S1, S2, S3, Value, Value2, V, V2>, impl Fn(MutMid) -> Option<MutValue2> + Clone + use<G1, G2, G3, L, Lock, LockValue, Mid, MidValue, MutLock, MutMid, MutRoot, MutValue, MutValue2, R, Root, S1, S2, S3, Value, Value2, V, V2>>
where V: 'static, V2: 'static, Value: Borrow<V>, Value2: Borrow<V2>, MutValue: BorrowMut<V>, MutValue2: BorrowMut<V2>, G3: Fn(Value) -> Option<Value2> + Clone, S3: Fn(MutValue) -> Option<MutValue2> + Clone,

Chain this AsyncLockKp with a regular crate::Kp (no root at call site). Returns an AsyncLockKp that goes one step further; use AsyncLockKp::get or AsyncLockKp::get_mut with root later.

§Example

// Root -> Arc<tokio::Mutex<Inner>> -> Inner -> field
let async_kp = AsyncLockKp::new(root_to_lock, TokioMutexAccess::new(), lock_to_inner);
let field_kp = Kp::new(|inner: &Inner| Some(&inner.field), |inner: &mut Inner| Some(&mut inner.field));
let chained = async_kp.then(field_kp);
let result = chained.get(&root).await;

Source

pub fn then_lock<Lock2, Mid2, V2, LockValue2, MidValue2, Value2, MutLock2, MutMid2, MutValue2, G2_1, S2_1, L2, G2_2, S2_2>( self, lock_kp: LockKp<V, Lock2, Mid2, V2, Value, LockValue2, MidValue2, Value2, MutValue, MutLock2, MutMid2, MutValue2, G2_1, S2_1, L2, G2_2, S2_2>, ) -> AsyncLockKpThenLockKp<R, V2, Root, Value2, MutRoot, MutValue2, Self, LockKp<V, Lock2, Mid2, V2, Value, LockValue2, MidValue2, Value2, MutValue, MutLock2, MutMid2, MutValue2, G2_1, S2_1, L2, G2_2, S2_2>>
where V: 'static, V2: 'static, Value: Borrow<V>, Value2: Borrow<V2>, MutValue: BorrowMut<V>, MutValue2: BorrowMut<V2>, LockValue2: Borrow<Lock2>, MidValue2: Borrow<Mid2>, MutLock2: BorrowMut<Lock2>, MutMid2: BorrowMut<Mid2>, G2_1: Fn(Value) -> Option<LockValue2>, S2_1: Fn(MutValue) -> Option<MutLock2>, L2: LockAccess<Lock2, MidValue2> + LockAccess<Lock2, MutMid2>, G2_2: Fn(MidValue2) -> Option<Value2>, S2_2: Fn(MutMid2) -> Option<MutValue2>,

Chain this AsyncLockKp with a sync crate::lock::LockKp (no root at call site). Returns a keypath that first goes through the async lock, then through the sync lock; use .get(&root).await later.

Source

pub fn then_async<Lock2, Mid2, V2, LockValue2, MidValue2, Value2, MutLock2, MutMid2, MutValue2, G2_1, S2_1, L2, G2_2, S2_2>( self, other: AsyncLockKp<V, Lock2, Mid2, V2, Value, LockValue2, MidValue2, Value2, MutValue, MutLock2, MutMid2, MutValue2, G2_1, S2_1, L2, G2_2, S2_2>, ) -> ComposedAsyncLockKp<R, V2, Root, Value2, MutRoot, MutValue2, Self, AsyncLockKp<V, Lock2, Mid2, V2, Value, LockValue2, MidValue2, Value2, MutValue, MutLock2, MutMid2, MutValue2, G2_1, S2_1, L2, G2_2, S2_2>>
where Lock: Clone, Lock2: Clone, V: 'static, V2: 'static, Value: Borrow<V>, LockValue2: Borrow<Lock2>, MidValue2: Borrow<Mid2>, Value2: Borrow<V2>, MutValue: BorrowMut<V>, MutLock2: BorrowMut<Lock2>, MutMid2: BorrowMut<Mid2>, MutValue2: BorrowMut<V2>, G2_1: Fn(Value) -> Option<LockValue2> + Clone, S2_1: Fn(MutValue) -> Option<MutLock2> + Clone, L2: AsyncLockLike<Lock2, MidValue2> + AsyncLockLike<Lock2, MutMid2> + Clone, G2_2: Fn(MidValue2) -> Option<Value2> + Clone, S2_2: Fn(MutMid2) -> Option<MutValue2> + Clone,

Chain with another async keypath (like crate::lock::LockKp::then_lock for sync locks).

Chain with another async keypath (e.g. tokio RwLock). Use ComposedAsyncLockKp::get or ComposedAsyncLockKp::get_mut with root later.

Root -> AsyncLock1 -> Container -> AsyncLock2 -> Value

§Example

// Root -> Arc<tokio::Mutex<Container>> -> Container -> Arc<tokio::Mutex<Value>> -> Value
let async_kp1 = AsyncLockKp::new(...); // Root -> Container
let async_kp2 = AsyncLockKp::new(...); // Container -> Value
let chained = async_kp1.then_async(async_kp2);
let result = chained.get(&root).await;