use std::str::FromStr;

                return Some(())

                Some(())
            },
            None => None,
        }
    }
    fn peek(&self) -> Option<()> {
        match self.top_token().next() {
            Some(_) => Some(()),
            None => None,
        }
    }
    pub fn assert_unique_top_token(&self) -> Result<()> {
        match self.peek() {
            None => Ok(()), 
            _ => Err(Error::new(ErrorKind::EUniqueTokenFMany)),
        }
    }
    pub fn val<T>(&self, key_path: &str) -> Result<T>
    where 
        T: FromStr,
        KeyTreeRef<'a>: TryInto<T>,
        KeyTreeRef<'a>: TryInto<T, Error = Error>,
    {
        let path = KeyPath::from_str(key_path);
        let kt = self.recurse(&path)?;
        kt.assert_unique_top_token()?;
        match kt.top_token() {
            Token::KeyValue { key, value, .. } => {
                match T::from_str(value) {
                    Ok(t) => Ok(t),
                    Err(err) => {
                        Err(Error::new(ErrorKind::FromStr(
                            format!("{}: {}", key, value),
                            format!("{}", kt.1),
                        )))
                    },
                }

            None => return None,

            _ => Err(Error::new(ErrorKind::EUniqueTokenFMany)),

        // Check that top token is unique
        match kt.top_token().next() {
            None => kt.try_into(),
            _ => Err(Error::new(ErrorKind::EUniqueTokenFMany)),
        }

        kt.assert_unique_top_token()?;
        kt.try_into()

                                Err(Error::new(ErrorKind::FailedFromStr(

                                Err(Error::new(ErrorKind::FromStr(

                                    into_type.to_string(),

    // `FromStr(value)` failed (key/value pair as string, position as string, into_type as string)
    FailedFromStr(String, String, String),

    // `FromStr(keyval, pos)
    FromStr(String, String),

            ErrorKind::FailedFromStr(_, _, _)       => None,

            ErrorKind::FromStr(_, _)                => None,

            ErrorKind::FailedFromStr(token, pos, into_type) => {

            ErrorKind::FromStr(token, pos) => {

                    "Error: Couldn't read string into type {} at {}: \"{}\".",
                    into_type, 

                    "Error: Couldn't parse string  at {}: \"{}\".",

            ErrorKind::FailedFromStr(token, pos, into_type) => {
                write!(
                    f,
                    "Error: Couldn't read string into type {} at {}: \"{}\".",
                    into_type, 
                    pos,
                    token, 
                )
            },

                ErrorKind::FailedFromStr(String::new(), String::new(), String::new()),

                ErrorKind::FromStr(String::new(), String::new(), String::new()),

                name: self.at("hobbit::name")?,
                age: self.at("hobbit::age")?,

                name: self.val("hobbit::name")?,
                age: self.val("hobbit::age")?,