Crate rust_key_paths 

Re-exports

pub use sync_kp::ArcMutexAccess;

pub use sync_kp::ArcRwLockAccess;

pub use sync_kp::LockAccess;

pub use sync_kp::SyncKp;

pub use sync_kp::SyncKpType;

pub use sync_kp::RcRefCellAccess;

pub use sync_kp::StdMutexAccess;

pub use sync_kp::StdRwLockAccess;

pub use kptrait::AccessorTrait;

pub use kptrait::ChainExt;

pub use kptrait::CoercionTrait;

pub use kptrait::HofTrait;

pub use kptrait::KeyPathValueTarget;

pub use kptrait::KpReadable;

pub use kptrait::KpTrait;

pub use kptrait::KPWritable;

Modules

async_lock

Async Lock Keypath Module

kptrait

Keypath traits: read/write surfaces, chaining, coercion, and higher-order helpers.

prelude

sync_kp

Sync keypath module (sync_kp)

Macros

get_or

Get value through a keypath or a default reference when the path returns None. Use with KpType: get_or!(User::name(), &user, &default) where default is &T (same type as the path value). Returns &T. Path syntax: get_or!(&user => User.name, &default).

get_or_else

Get value through a keypath, or compute an owned fallback when the path returns None. Use with KpType: get_or_else!(User::name(), &user, || "default".to_string()). Returns T (owned). The keypath’s value type must be Clone. The closure is only called when the path is None. Path syntax: get_or_else!(&user => (User.name), || "default".to_string()) — path in parentheses.

keypath

Build a keypath from Type.field segments. Use with types that have keypath accessors (e.g. #[derive(Kp)] from key-paths-derive).

zip_with_kp

Zip multiple keypaths on the same root and apply a closure to the tuple of values. Returns Some(closure((v1, v2, ...))) when all keypaths succeed, else None.

Structs

AKp

EnumKp

EnumKp - A keypath for enum variants that supports both extraction and embedding Leverages the existing Kp architecture where optionals are built-in via Option

Kp

Kp — typed keypath with getter/setter closures. See also AKp for type-erased keypaths.

PKp

Functions

constrain_get

Forces the compiler to treat a closure as for<'b> Fn(&'b R) -> Option<&'b V>.

constrain_set

Forces the compiler to treat a closure as for<'b> Fn(&'b mut R) -> Option<&'b mut V>.

enum_err

Extract from Result<T, E> - Err variant

enum_ok

Extract from Result<T, E> - Ok variant

enum_some

Extract from Option - Some variant

enum_variant

Create an enum keypath with both extraction and embedding for a specific variant

kp_arc

Create a keypath for unwrapping Arc -> T (read-only)

kp_box

Create a keypath for unwrapping Box -> T

kp_rc

Create a keypath for unwrapping Rc -> T (read-only)

variant_of

Create an enum keypath for a specific variant with type inference

zip_kps

Zip two keypaths together to create a tuple Works only with KpType (reference-based keypaths)

Type Aliases

EnumKpType

KpArc

KpBox

KpComposed

KpDynamic

KpOptionRefCellType

Keypath for Option<RefCell<T>>: get returns Option<Ref<V>> so the caller holds the guard. Use .get(root).as_ref().map(std::cell::Ref::deref) to get Option<&V> while the Ref is in scope.

KpOwned

Kp will force dev to create get and set while root and value both will be owned

KpRoot

Kp will force dev to create get and set while taking full ownership of the Root while returning Root as value.

KpTraitType

KpType

KpValue

Kp will force dev to create get and set while value will be owned

KpVoid

Kp for void - experimental