pub fn append<T>(&self, other: &KeyPath<Value, T>) -> KeyPath<Root, T> {
        let mut partial = self.partial.clone();
        partial
            .fields
            .to_mut()
            .extend(other.partial.fields.iter().clone());
        KeyPath {
            partial,
            _value: other._value,
        }
    }
/// 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);
/// ```
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.
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 .
pub fn append<T>(&self, other: &KeyPath<Value, T>) -> KeyPath<Root, T> {
        let mut partial = self.partial.clone();
        partial
            .fields
            .to_mut()
            .extend(other.partial.fields.iter().clone());
        KeyPath {
            partial,
            _value: other._value,
        }
    }
pub fn append < T > ( & self , other : & KeyPath < Value , T > ) -> KeyPath < Root , T > { let mut partial = self . partial . clone ( ) ; partial . fields . to_mut ( ) . extend ( other . partial . fields . iter ( ) . clone ( ) ) ; KeyPath { partial , _value : other . _value , } }
Create a new `KeyPath` by combining two routes.
Create a new ` KeyPath ` by combining two routes .
&self
other
&KeyPath<Value, T>
&self
other
&KeyPath<Value, T>
examples
```
use keypath::{Keyable, KeyPath, keypath}.
` ` ` use keypath :: { Keyable KeyPath keypath } .
[derive(keyable)]
struct Person {
name: String,
friends: Vec,
size: Size,
}
struct Person { name : String friends : Vec 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).


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 ) .