Add helpers to deserialize into Option or Result

[romac]

cc @bugarela

Option

use serde::Deserialize;
use serde_json::json;

use itf::de::{self, As};

#[derive(Debug, PartialEq, Deserialize)]
struct FooOption {
    #[serde(with = "As::<de::Option::<_>>")]
    foo: Option<u64>,
}

let some_itf = json!({
    "foo": {
        "tag": "Some",
        "value": 42,
    }
});

let some_foo = itf::from_value::<FooOption>(some_itf).unwrap();
assert_eq!(some_foo, FooOption { foo: Some(42) });

let none_itf = json!({
    "foo": {
        "tag": "None",
        "value": {},
    }
});

let none_foo = itf::from_value::<FooOption>(none_itf).unwrap();
assert_eq!(none_foo, FooOption { foo: None });

Result

use serde::Deserialize;
use serde_json::json;

use itf::de::{self, As};

#[derive(Debug, PartialEq, Deserialize)]
struct FooResult {
    #[serde(with = "As::<de::Result::<_, _>>")]
    foo: Result<u64, u64>,
}

let ok_itf = json!({
    "foo": {
        "tag": "Ok",
        "value": 42,
    }
});

let ok = itf::from_value::<FooResult>(ok_itf).unwrap();
assert_eq!(ok.foo, Ok(42));

let err_itf = json!({
    "foo": {
        "tag": "Err",
        "value": 42,
    }
});

let err = itf::from_value::<FooResult>(err_itf).unwrap();
assert_eq!(err.foo, Err(42));

[bugarela]

Thanks a lot @romac, this is exactly what I need!