Struct PartialKeyPath 

pub struct PartialKeyPath<Root> { /* private fields */ }

PartialKeyPath - Hides the Value type but keeps Root visible Useful for storing keypaths in collections without knowing the exact Value type

Why PhantomData?

PhantomData<Root> is needed because:

1. The Root type parameter is not actually stored in the struct (only used in the closure)
2. Rust needs to know the generic type parameter for:
   • Type checking at compile time
   • Ensuring correct usage (e.g., PartialKeyPath<User> can only be used with &User)
   • Preventing mixing different Root types
3. Without PhantomData, Rust would complain that Root is unused
4. PhantomData is zero-sized - it adds no runtime overhead

Implementations

impl<Root> PartialKeyPath<Root>

pub fn new<Value>( keypath: KeyPath<Root, Value, impl for<'r> Fn(&'r Root) -> &'r Value + 'static>, ) -> PartialKeyPath<Root>

where Value: Any + 'static, Root: 'static,

pub fn from<Value>( keypath: KeyPath<Root, Value, impl for<'r> Fn(&'r Root) -> &'r Value + 'static>, ) -> PartialKeyPath<Root>

where Value: Any + 'static, Root: 'static,

Create a PartialKeyPath from a concrete KeyPath Alias for new() for consistency with from() pattern

pub fn get<'r>(&self, root: &'r Root) -> &'r (dyn Any + 'static)

pub fn value_type_id(&self) -> TypeId

Get the TypeId of the Value type

pub fn get_as<'a, Value>(&self, root: &'a Root) -> Option<&'a Value>

where Value: Any,

Try to downcast the result to a specific type

pub fn kind_name(&self) -> String

Get a human-readable name for the value type Returns a string representation of the TypeId

pub fn for_arc(&self) -> PartialOptionalKeyPath<Arc<Root>>

where Root: 'static,

Adapt this keypath to work with Arc instead of Root

pub fn for_box(&self) -> PartialOptionalKeyPath<Box<Root>>

where Root: 'static,

Adapt this keypath to work with Box instead of Root

pub fn for_rc(&self) -> PartialOptionalKeyPath<Rc<Root>>

where Root: 'static,

Adapt this keypath to work with Rc instead of Root

pub fn for_option(&self) -> PartialOptionalKeyPath<Option<Root>>

where Root: 'static,

Adapt this keypath to work with Option instead of Root

pub fn for_result<E>(&self) -> PartialOptionalKeyPath<Result<Root, E>>

where Root: 'static, E: 'static,

Adapt this keypath to work with Result<Root, E> instead of Root

pub fn for_arc_rwlock(&self) -> PartialOptionalKeyPath<Arc<RwLock<Root>>>

where Root: Clone + 'static,

Adapt this keypath to work with Arc<RwLock> instead of Root Note: This requires the Root to be cloned first, then use the keypath on the cloned value Example: keypath.get_as::<Value>(&arc_rwlock.read().unwrap().clone())

pub fn for_arc_mutex(&self) -> PartialOptionalKeyPath<Arc<Mutex<Root>>>

where Root: Clone + 'static,

Adapt this keypath to work with Arc<Mutex> instead of Root Note: This requires the Root to be cloned first, then use the keypath on the cloned value Example: keypath.get_as::<Value>(&arc_mutex.lock().unwrap().clone())

Trait Implementations

impl<Root> Clone for PartialKeyPath<Root>

where Root: Clone,

fn clone(&self) -> PartialKeyPath<Root>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Root> From<PartialKeyPath<Root>> for PKP<Root>

fn from(kp: RustPartialKeyPath<Root>) -> Self

Converts to this type from the input type.