Enum KP 

pub enum KP<Root> {
    KeyPath(PartialKeyPath<Root>),
    OptionalKeyPath(PartialOptionalKeyPath<Root>),
    WritableKeyPath(PartialWritableKeyPath<Root>),
    WritableOptionalKeyPath(PartialWritableOptionalKeyPath<Root>),
}

Enum for basic keypath types (KeyPath, OptionalKeyPath, WritableKeyPath, WritableOptionalKeyPath).

Provides syntactic sugar for functions accepting any basic keypath type.

Example

fn process_keypath<Root>(kp: KP<Root>) {
    match kp {
        KP::KeyPath(k) => { /* handle KeyPath */ },
        KP::OptionalKeyPath(k) => { /* handle OptionalKeyPath */ },
        KP::WritableKeyPath(k) => { /* handle WritableKeyPath */ },
        KP::WritableOptionalKeyPath(k) => { /* handle WritableOptionalKeyPath */ },
    }
}

Variants

KeyPath(PartialKeyPath<Root>)

A readable keypath that always succeeds.

OptionalKeyPath(PartialOptionalKeyPath<Root>)

A readable keypath that may return None.

WritableKeyPath(PartialWritableKeyPath<Root>)

A writable keypath that always succeeds.

WritableOptionalKeyPath(PartialWritableOptionalKeyPath<Root>)

A writable keypath that may return None.

Implementations

impl<Root> KP<Root>

pub fn from_keypath<Value, F>(kp: RustKeyPath<Root, Value, F>) -> Self

where F: for<'r> Fn(&'r Root) -> &'r Value + 'static, Root: 'static, Value: Any + 'static,

Convert from a concrete rust_keypaths::KeyPath.

pub fn from_optional_keypath<Value, F>( kp: RustOptionalKeyPath<Root, Value, F>, ) -> Self

where F: for<'r> Fn(&'r Root) -> Option<&'r Value> + 'static, Root: 'static, Value: Any + 'static,

Convert from a concrete rust_keypaths::OptionalKeyPath.

pub fn from_writable_keypath<Value, F>( kp: RustWritableKeyPath<Root, Value, F>, ) -> Self

where F: for<'r> Fn(&'r mut Root) -> &'r mut Value + 'static, Root: 'static, Value: Any + 'static,

Convert from a concrete rust_keypaths::WritableKeyPath.

pub fn from_writable_optional_keypath<Value, F>( kp: RustWritableOptionalKeyPath<Root, Value, F>, ) -> Self

where F: for<'r> Fn(&'r mut Root) -> Option<&'r mut Value> + 'static, Root: 'static, Value: Any + 'static,

Convert from a concrete rust_keypaths::WritableOptionalKeyPath.

Trait Implementations

impl<Root, Value, F> From<KeyPath<Root, Value, F>> for KP<Root>

where F: for<'r> Fn(&'r Root) -> &'r Value + 'static, Root: 'static, Value: Any + 'static,

fn from(kp: RustKeyPath<Root, Value, F>) -> Self

Converts to this type from the input type.

impl<Root, Value, F> From<OptionalKeyPath<Root, Value, F>> for KP<Root>

where F: for<'r> Fn(&'r Root) -> Option<&'r Value> + 'static, Root: 'static, Value: Any + 'static,

fn from(kp: RustOptionalKeyPath<Root, Value, F>) -> Self

Converts to this type from the input type.

impl<Root, Value, F> From<WritableKeyPath<Root, Value, F>> for KP<Root>

where F: for<'r> Fn(&'r mut Root) -> &'r mut Value + 'static, Root: 'static, Value: Any + 'static,

fn from(kp: RustWritableKeyPath<Root, Value, F>) -> Self

Converts to this type from the input type.

impl<Root, Value, F> From<WritableOptionalKeyPath<Root, Value, F>> for KP<Root>

where F: for<'r> Fn(&'r mut Root) -> Option<&'r mut Value> + 'static, Root: 'static, Value: Any + 'static,

fn from(kp: RustWritableOptionalKeyPath<Root, Value, F>) -> Self

Converts to this type from the input type.