JSON to Rust

What the generator emits

Every object becomes a pub struct carrying #[derive(Debug, Clone, Serialize, Deserialize)]. Field names are converted to snake_case, and any key whose snake_case form differs keeps its wire spelling in a #[serde(rename = "…")] attribute — so the Rust you read stays idiomatic while the JSON stays byte-for-byte compatible.

Optional keys become Option<T>

Rust has no field-level "not present" state, so optionality has to come from Option. The generator marks a field Option<T> when the key was null, or when it appeared in one element of an array but not in its siblings:

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Address {
    pub city: String,
    #[serde(rename = "zipCode")]
    pub zip_code: Option<String>,
}

Without Option, serde would reject a payload with the key missing. Turn on Skip serialising absent fields to also add #[serde(skip_serializing_if = "Option::is_none")], which keeps null out of your outgoing JSON instead of writing one explicitly.

Using the structs

use serde_json;

let payload: Root = serde_json::from_str(&body)?;
println!("{}", payload.address.city);

// Round-trip back to the wire format
let text = serde_json::to_string(&payload)?;

Your Cargo.toml needs serde with the derive feature, plus serde_json for Value:

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Edge cases worth knowing

• Numbers are not narrowed. A JSON 1 becomes i64 even if it is obviously a count — narrow types are a decision the generator cannot make for you.
• Mixed arrays such as [1, "two"] fall back to serde_json::Value, since Rust has no untagged union to describe them.
• Empty arrays become Vec<serde_json::Value> — the sample simply contains no element to infer from.
• Recursive types are not possible here. A JSON document is a tree, so the generated structs never refer back to themselves and always compile as-is.

FAQ