Struct KeyPath

pub struct KeyPath<Root: ?Sized, Value: 'static> { /* private fields */ }

A non-fallible keypath.

Implementations

impl<Root, Value> KeyPath<Root, Value>

pub fn append<T>(&self, other: &KeyPath<Value, T>) -> KeyPath<Root, T>

Create a new KeyPath by combining two routes.

The final type of the first route must be the first type of the second route; assuming both paths were created with the keypath! macro, the resulting path must be valid.

Examples

use keypath::{Keyable, KeyPath, keypath};

#[derive(Keyable)]
struct Person {
    name: String,
    friends: Vec<String>,
    size: Size,
}

#[derive(Keyable)]
struct Size {
    big: bool,
    heft: u8,
}

let mut person = Person {
    name: "coco".into(),
    friends: vec!["eli".into(), "nico".into(), "yaya".into()],
    size: Size { big: false, heft: 45 }
};

let size = keypath!(Person.size);
let heft = keypath!(Size.heft);
let combined = size.append(&heft);

assert_eq!(person[&combined], 45);

Trait Implementations

impl<Root: ?Sized, Value: 'static> AsRef<[PathComponent]> for KeyPath<Root, Value>

fn as_ref(&self) -> &[PathComponent]

Converts this type into a shared reference of the (usually inferred) input type.