Crate rust_key_paths

Re-exports§

async_lock: Async Lock Keypath Module
kptrait: Keypath extensions for crate::Kp: chaining, coercion, and higher-order helpers.
prelude
sync_kp: Sync keypath module (sync_kp)

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.

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

AccessorTrait: Optional-root and fallback helpers built on Readable / Writable.
KeyPath: A keypath that supports both read and write navigation.
KeyPathValueTarget: Used so async chaining can infer the referent of a reference-valued step (e.g. &T and &mut T both map to T).
KpTrait: Logical root/value type identity and composition for a keypath.
Readable: Read-only keypath: navigate from Root to Value.
Shr: The right shift operator >>. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ >> _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a >> b and a.shr(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.
Writable: Mutable keypath: setter path (same semantics as a get_mut closure on many keypath APIs).

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)

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