let map = match value
    .method()
    .another_method()
{
    serde_json::Value::Object(o) => o,
    _ => panic!("expected an object")
};

let map: serde_json::Map<_, _> = value
    .method()
    .another_method()
    .try_into()
    .expect("expected an object");

use core::convert::TryInto;

impl TryFrom<&Value> for i64 {
    type Error = Error;

    fn try_from(value: &Value) -> Result<Self, Self::Error> {
        value
            .as_i64()
            .ok_or(serde::de::Error::custom("Cannot interpret Value as i64"))
    }
}

impl<'a> TryFrom<&'a Value> for &'a str {
    type Error = Error;

    fn try_from(value: &'a Value) -> Result<Self, Self::Error> {
        value
            .as_str()
            .ok_or(serde::de::Error::custom("Cannot interpret Value as &str"))
    }
}

    fn get_property<'a, T>(val: &'a Value, name: &str) -> std::result::Result<T, T::Error>
    where
        T: TryFrom<&'a Value>,
        <T as std::convert::TryFrom<&'a Value>>::Error: serde::de::Error,
    {
        val.as_object()
            .ok_or(serde::de::Error::custom("value is not an object"))?
            .get(name)
            .ok_or(serde::de::Error::custom("no property found"))?
            .try_into()
    }


    #[test]
    fn it_works() {
        let j_son = json!({"number": 1, "str": "hello"});

        // Don't consume j_son, so I can call it many times
        assert_eq!(get_property::<i64>(&j_son, "number").unwrap(), 1);
        assert_eq!(get_property::<&str>(&j_son, "str").unwrap(), "hello");
    }