When using serde, your types become entangled with serialization logic due to the Serialize and Deserialize traits.

This crate lets you decouple serialization logic by leveraging simple functions, at some performance cost:

use decoder::{Result, Value};

struct Person {
    name: String,
    projects: Vec<Project>,
}

struct Project {
    name: String,
    url: String,
}

impl Person {
    fn decode(value: Value) -> Result<Self> {
        use decoder::decode::sequence;

        let mut person = value.into_map()?;

        Ok(Self {
            name: person.required("name")?,
            projects: person.required_with("projects", sequence(Project::decode))?,
        })
    }

    fn encode(&self) -> Value {
        use decoder::encode::{map, sequence};

        map!(
            name = &self.name,
            projects = sequence(Project::encode, &self.projects)
        )
        .into()
    }
}

impl Project {
    fn decode(value: Value) -> Result<Self> {
        let mut project = value.into_map()?;

        Ok(Project {
            name: project.required("name")?,
            url: project.required("url")?,
        })
    }

    fn encode(&self) -> Value {
        use decoder::encode::map;

        map!(name = &self.name, url = &self.url).into()
    }
}

let person =
    decoder::run(serde_json::from_str, Person::decode, "{ ... }").expect("Decode person");

let _ = serde_json::to_string(&person.encode());

You can try this crate if the serde way™ has become painful or it does not resonate with you.