Enum KeyPaths 

pub enum KeyPaths<Root, Value> {
    Readable(Rc<dyn for<'a> Fn(&'a Root) -> &'a Value>),
    ReadableEnum {
        extract: Rc<dyn for<'a> Fn(&'a Root) -> Option<&'a Value>>,
        embed: Rc<dyn Fn(Value) -> Root>,
    },
    FailableReadable(Rc<dyn for<'a> Fn(&'a Root) -> Option<&'a Value>>),
    Writable(Rc<dyn for<'a> Fn(&'a mut Root) -> &'a mut Value>),
    FailableWritable(Rc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut Value>>),
    WritableEnum {
        extract: Rc<dyn for<'a> Fn(&'a Root) -> Option<&'a Value>>,
        extract_mut: Rc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut Value>>,
        embed: Rc<dyn Fn(Value) -> Root>,
    },
}

Variants

Readable(Rc<dyn for<'a> Fn(&'a Root) -> &'a Value>)

ReadableEnum

Fields

extract: Rc<dyn for<'a> Fn(&'a Root) -> Option<&'a Value>>

embed: Rc<dyn Fn(Value) -> Root>

FailableReadable(Rc<dyn for<'a> Fn(&'a Root) -> Option<&'a Value>>)

Writable(Rc<dyn for<'a> Fn(&'a mut Root) -> &'a mut Value>)

FailableWritable(Rc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut Value>>)

WritableEnum

Fields

extract: Rc<dyn for<'a> Fn(&'a Root) -> Option<&'a Value>>

extract_mut: Rc<dyn for<'a> Fn(&'a mut Root) -> Option<&'a mut Value>>

embed: Rc<dyn Fn(Value) -> Root>

Implementations

impl<Root, Value> KeyPaths<Root, Value>

pub fn readable( get: impl for<'a> Fn(&'a Root) -> &'a Value + 'static, ) -> KeyPaths<Root, Value>

pub fn writable( get_mut: impl for<'a> Fn(&'a mut Root) -> &'a mut Value + 'static, ) -> KeyPaths<Root, Value>

pub fn failable_readable( get: impl for<'a> Fn(&'a Root) -> Option<&'a Value> + 'static, ) -> KeyPaths<Root, Value>

pub fn failable_writable( get_mut: impl for<'a> Fn(&'a mut Root) -> Option<&'a mut Value> + 'static, ) -> KeyPaths<Root, Value>

pub fn readable_enum( embed: impl Fn(Value) -> Root + 'static, extract: impl for<'a> Fn(&'a Root) -> Option<&'a Value> + 'static, ) -> KeyPaths<Root, Value>

pub fn writable_enum( embed: impl Fn(Value) -> Root + 'static, extract: impl for<'a> Fn(&'a Root) -> Option<&'a Value> + 'static, extract_mut: impl for<'a> Fn(&'a mut Root) -> Option<&'a mut Value> + 'static, ) -> KeyPaths<Root, Value>

impl<Root, Value> KeyPaths<Root, Value>

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

Get an immutable reference if possible

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

Get a mutable reference if possible

pub fn embed(&self, value: Value) -> Option<Root>

where Value: Clone,

pub fn embed_mut(&self, value: Value) -> Option<Root>

where Value: Clone,

pub fn iter<'a, T>( &'a self, root: &'a Root, ) -> Option<<&'a Value as IntoIterator>::IntoIter>

where &'a Value: IntoIterator<Item = &'a T>, T: 'a,

Iter over immutable references if Value: IntoIterator

pub fn iter_mut<'a, T>( &'a self, root: &'a mut Root, ) -> Option<<&'a mut Value as IntoIterator>::IntoIter>

where &'a mut Value: IntoIterator<Item = &'a mut T>, T: 'a,

Iter over mutable references if &mut Value: IntoIterator

pub fn into_iter<T>( self, root: Root, ) -> Option<<Value as IntoIterator>::IntoIter>

where Value: IntoIterator<Item = T> + Clone,

Consume root and iterate if Value: IntoIterator

impl<Root, Mid> KeyPaths<Root, Mid>

where Root: 'static, Mid: 'static,

pub fn then<Value>(self, mid: KeyPaths<Mid, Value>) -> KeyPaths<Root, Value>

where Value: 'static,

Alias for compose for ergonomic chaining.

pub fn compose<Value>(self, mid: KeyPaths<Mid, Value>) -> KeyPaths<Root, Value>

where Value: 'static,

Trait Implementations

impl<Root, Value> Clone for KeyPaths<Root, Value>

where Root: Clone, Value: Clone,

fn clone(&self) -> KeyPaths<Root, Value>

Returns a duplicate of the value.

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

Performs copy-assignment from source.