thread '<main>' panicked at 'called Result::unwrap() on an Err value: SyntaxError("expected value", 0, 0)'

[linuxaged]

I written a serde example to do some deserializing, but got the error:

src/main.rs:12:5: 12:30 warning: unused result which must be used, #[warn(unused_must_use)] on by default
src/main.rs:12     f.read_to_string(&mut s);
                   ^~~~~~~~~~~~~~~~~~~~~~~~~
src/main.rs:14:51: 14:58 warning: unused attribute, #[warn(unused_attributes)] on by default
src/main.rs:14     #[derive(Copy, Clone, Serialize, Deserialize, Display, Debug)]
                                                                 ^~~~~~~
     Running `target/debug/serde_example`
thread '<main>' panicked at 'called `Result::unwrap()` on an `Err` value: SyntaxError("expected value", 0, 0)', ../src/libcore/result.rs:731

what has happened? How to debug this?

[linuxaged]

Sorry, it's my fault. The result can not map to Vec<Vertex>, i should deserialize to Vec<f64> then convert to Vec<Vertex>.

[erickt]

No problem! Going through a Vec<f64> is fine, but if you do want to cut down on that translation, you could instead use a custom deserializer to do like this:

impl serde::Deserialize for Vertex {
    #[inline]
    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
        where D: serde::Deserializer,

        let vertices: [f64, 16] = try!(serde::Deserialize::visit_seq(visitor));

        Ok(Vertex {
            position:[vertices[0], vertices[1],vertices[2]],
            normal:[vertices[3], vertices[4], vertices[5]],
            texcood:[vertices[6], vertices[7]],
            blendweight:[vertices[8], vertices[9], vertices[10], vertices[11]],
            blendindex:[vertices[12], vertices[13],vertices[14], vertices[15]]
        })
    }
}

It might be possible to do away with that inner [f64, 16] with a state machine, but I wouldn't be surprised if the compiler was able to optimize it away and just create the Vertex with no copy.

[linuxaged]

try!(serde::Deserialize::visit_seq(visitor)); which visitor should i use here?
It is really tricky for a newcomer, any detailed document about how to write a custom deserializer for a struct ?

[erickt]

@linuxaged: Yeah I'm slowly adding more docs, but there's plenty more I need to do.

You're right, I had a mistake, it really should be:

impl serde::Deserialize for Vertex {
    #[inline]
    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
        where D: serde::Deserializer,

        let vertices: [f64, 16] = try!(serde::Deserialize::deserialize(deserializer));

        Ok(Vertex {
            position:[vertices[0], vertices[1],vertices[2]],
            normal:[vertices[3], vertices[4], vertices[5]],
            texcood:[vertices[6], vertices[7]],
            blendweight:[vertices[8], vertices[9], vertices[10], vertices[11]],
            blendindex:[vertices[12], vertices[13],vertices[14], vertices[15]]
        })
    }
}

Sorry about that.

[linuxaged]

Thanks for your support.
How about writing a custom deserializer deserializing a [f64; n * 16] array directly into Vec<Vertex> ?
We can only write custom deserializer for first order types, can not for two order types like Vec<Vertex>, right?

[erickt]

@linuxaged: Unfortunately we can't do specialization like that yet. Since serde has an impl for Vec<T> we can't also have a impl for Vec<Vertex>. However, you could create a newtyped struct as in struct Vertices(Vec<Vertex>) and then write an implementation for that. Then you could deserialize directly from a [f64; n * 16] into the Vertices type.

[tomprogrammer]

For reference: RFC: impl specialization