关联类型的实例上的模式匹配困难

Question

I am relying on rustc_serialize to parse JSON data into a struct, Orders , which represents a Vec of Order structs. The JSON data may have an array or a null value; my intent is to either parse the array of orders normally, if any, or parse the null value as an Orders with an empty Vec . If neither of these is the case, then an error is to be relayed. This is my attempt:

impl Decodable for Orders {
    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
        let try = d.read_seq(|d, l| {
            let mut orders = Vec::new();
            for _ in 0..l {
                let order = try!(Decodable::decode(d));
                orders.push(order);
            }
            Ok(Orders(orders))
        });

        match try {
            value @ Ok(_) => value,
            error @ Err(e) => match e {
                ExpectedError(_, x) if &x == "null" => Ok(Orders(Vec::new())),
                _ => error,
            },
        }
    } 
}

My issue has to do with pattern matching on ExpectedError . The compiler gives me the following error:

 expected `<D as rustc_serialize::serialize::Decoder>::Error`,
    found `rustc_serialize::json::DecoderError`
(expected associated type,
    found enum `rustc_serialize::json::DecoderError`) [E0308]
src/api/types/json.rs:125                 ExpectedError(_, x) if &x == "null" => Ok(Orders(Vec::new())),
                                          ^~~~~~~~~~~~~~~~~~~

I am stumped on this one. How can I correct this?

Answer 1

How can I correct this?

In general, you would have to choose between being generic or specialized. You cannot pattern match on an associated type because this type can be anything and a generic method should work for any type which satisfies the constraints.

For example, in your case:

• <D as rustc_serialize::serialize::Decoder>::Error can be anything
• rustc_serialize::json::DecoderError is but one possibility

So you should normally choose between using some abstract D or specializing the decoding for json .

---

However, since you are implementing Decodable here, you cannot choose NOT to be generic as you do not get to pick the signature.

Furthermore, it appears that rustc_serialize does not support tentative parsing (or at least, its json implementation does not), so I am afraid that you cannot check for nullity (using d.read_nil() ) beforehand.

I suppose those limitations can be seen as the reason that this library is being retired in favor of serde , and can only encourage you to try it out.