Compare Versions - serde

Crates.io/serde/Compare Versions

View on Crates.io

From:→To:

1.0.228

Allow building documentation with RUSTDOCFLAGS='--cfg=docsrs' set for the whole dependency graph (#2995)

1.0.227

Documentation improvements (#2991)

1.0.226

Deduplicate variant matching logic inside generated Deserialize impl for adjacently tagged enums (#2935, thanks @Mingun)

1.0.225

Avoid triggering a deprecation warning in derived Serialize and Deserialize impls for a data structure that contains its own deprecations (#2879, thanks @rcrisanti)

1.0.224

Remove private types being suggested in rustc diagnostics (#2979)

1.0.223

Fix serde_core documentation links (#2978)

1.0.222

Make serialize_with attribute produce code that works if respanned to 2024 edition (#2950, thanks @aytey)

1.0.221

Documentation improvements (#2973)
Deprecate serde_if_integer128! macro (#2975)

1.0.220

Add a way for data formats to depend on serde traits without waiting for serde_derive compilation: https://docs.rs/serde_core (#2608, thanks @osiewicz)

1.0.219

Prevent absolute_paths Clippy restriction being triggered inside macro-generated code (#2906, thanks @davidzeng0)

1.0.218

Documentation improvements

1.0.217

Support serializing externally tagged unit variant inside flattened field (#2786, thanks @Mingun)

1.0.216

Mark all generated impls with #[automatically_derived] to exclude from code coverage (#2866, #2868, thanks @tdittr)

1.0.215

Produce warning when multiple fields or variants have the same deserialization name (#2855, #2856, #2857)

1.0.214

Implement IntoDeserializer for all Deserializers in serde::de::value module (#2568, thanks @Mingun)

1.0.213

Fix support for macro-generated with attributes inside a newtype struct (#2847)

1.0.212

Fix hygiene of macro-generated local variable accesses in serde(with) wrappers (#2845)

1.0.211

Improve error reporting about mismatched signature in with and default attributes (#2558, thanks @Mingun)
Show variant aliases in error message when variant deserialization fails (#2566, thanks @Mingun)
Improve binary size of untagged enum and internally tagged enum deserialization by about 12% (#2821)

1.0.210

Support serializing and deserializing IpAddr and SocketAddr in no-std mode on Rust 1.77+ (#2816, thanks @MathiasKoch)
Make serde::ser::StdError and serde::de::StdError equivalent to core::error::Error on Rust 1.81+ (#2818)

1.0.209

Fix deserialization of empty structs and empty tuples inside of untagged enums (#2805, thanks @Mingun)

1.0.208

Support serializing and deserializing unit structs in a flatten field (#2802, thanks @jonhoo)

1.0.207

Improve interactions between flatten attribute and skip_serializing/skip_deserializing (#2795, thanks @Mingun)

1.0.206

Improve support for flatten attribute inside of enums (#2567, thanks @Mingun)

1.0.205

Use serialize_entry instead of serialize_key + serialize_value when serialize flattened newtype enum variants (#2785, thanks @Mingun)
Avoid triggering a collection_is_never_read lint in the deserialization of enums containing flattened fields (#2791)

1.0.204

Apply #[diagnostic::on_unimplemented] attribute on Rust 1.78+ to suggest adding serde derive or enabling a "serde" feature flag in dependencies (#2767, thanks @weiznich)

1.0.203

Documentation improvements (#2747)

1.0.202

Provide public access to RenameAllRules in serde_derive_internals (#2743)

1.0.201

Resolve unexpected_cfgs warning (#2737)

1.0.200

Fix formatting of "invalid type" and "invalid value" deserialization error messages containing NaN or infinite floats (#2733, thanks @jamessan)

1.0.199

Fix ambiguous associated item when forward_to_deserialize_any! is used on an enum with Error variant (#2732, thanks @aatifsyed)

1.0.198

Support serializing and deserializing Saturating<T> (#2709, thanks @jbethune)

1.0.197

Fix unused_imports warnings when compiled by rustc 1.78
Optimize code size of some Display impls (#2697, thanks @nyurik)

1.0.196

Improve formatting of "invalid type" error messages involving floats (#2682)

1.0.195

Prevent remote definitions of tuple struct or tuple variant from triggering dead_code warning (#2671)

1.0.194

Update proc-macro2 to fix caching issue when using a rustc-wrapper such as sccache

1.0.193

Fix field names used for the deserialization of RangeFrom and RangeTo (#2653, #2654, #2655, thanks @emilbonnek)

1.0.192

Allow internal tag field in untagged variant (#2646, thanks @robsdedude)

1.0.191

Documentation improvements

1.0.190

Preserve NaN sign when deserializing f32 from f64 or vice versa (#2637)

1.0.189

Fix "cannot infer type" error when internally tagged enum contains untagged variant (#2613, thanks @ahl)

1.0.188

Fix "failed to parse manifest" error when building serde using a Cargo version between 1.45 and 1.50 (#2603)

1.0.187

Remove support for Emscripten targets on rustc older than 1.40 (#2600)

1.0.186

Disallow incompatible versions of serde_derive and serde in the dependency graph (#2588, thanks @soqb)

1.0.185

Fix error "cannot move out of *self which is behind a shared reference" deriving Serialize on a non_exhaustive enum (#2591)

1.0.184

Restore from-source serde_derive build on all platforms — eventually we'd like to use a first-class precompiled macro if such a thing becomes supported by cargo / crates.io

1.0.183

Support deserializing Box<OsStr> with an equivalent representation as OsString (#2556, thanks @DBLouis)

1.0.182

Render field aliases in sorted order in error messages (#2458, thanks @Mingun)
Support serde(default) on tuple structs (#2553, thanks @Mingun)

1.0.181

Make serde(alias) work in combination with flatten when using in-place deserialization (#2443, thanks @Mingun)
Improve the representation of adjacently tagged enums in formats where enum tags are serialized by index, as opposed to by string name (#2505, #2496, thanks @Baptistemontan)

1.0.180

Update to 2018 edition

1.0.179

Support serialization of tuple variants inside a flattened field (#2448, thanks @Mingun)

1.0.178

Fix build error when using serde with "std" feature turned off and "unstable" feature turned on (#2541)

1.0.177

Add serde(rename_all_fields = "...") attribute to apply a rename_all on every struct variant of an enum (#1695, thanks @jplatte)
Improve diagnostics for attribute parse errors (#2536, thanks @jplatte)

1.0.176

Allow tag field of an internally tagged enum to have same name as a field inside a skipped struct variant (#2266, thanks @flisky)

1.0.175

Restore missing LICENSE files in serde_derive crate (#2527, thanks @ankane)

1.0.174

Documentation improvements

1.0.173

Fix missing trait implementations when using serde derive macro on a macro-generated data structure, such as via the bitflags crate (#2516)

1.0.172

Experiment with precompiling the serde_derive macros to reduce build time (#2514)

1.0.171

Support derive(Deserialize) on unit structs that have const generics (#2500, thanks @Baptistemontan)

1.0.170

Produce error message on suffixed string literals inside serde attributes (#2242)
Support single identifier as unbraced default value for const generic parameter (#2449)

1.0.169

Add Deserializer::deserialize_identifier support for adjacently tagged enums (#2475, thanks @Baptistemontan)
Fix unused_braces lint in generated Deserialize impl that uses braced const generic expressions (#2414)

1.0.168

Allow serde::de::IgnoredAny to be the type for a serde(flatten) field (#2436, thanks @Mingun)
Allow larger preallocated capacity for smaller elements (#2494)

1.0.167

Add serialize and deserialize impls for RangeFrom and RangeTo (#2471, thanks @tbu-)

1.0.166

Add no-alloc category to crates.io metadata

1.0.165

Fix incorrect count of fields passed to tuple deserialization methods when using serde(skip_deserializing) attributes (#2466, thanks @Mingun)
Fix -Zminimal-versions build

1.0.164

Allowed enum variants to be individually marked as untagged (#2403, thanks @dewert99)

1.0.163

Eliminate build script from serde_derive crate to slightly reduce build time (#2442, thanks @taiki-e)

1.0.162

Support deserializing flattened adjacently tagged enums from data formats which represent fields as bytes, such as the csv crate (#2377, thanks @mfro)

#[derive(Deserialize)]
pub struct Record {
    common: u64,
    #[serde(flatten)]
    kind: Kind,
}

#[derive(Deserialize)]
#[serde(tag = "kind", content = "parameter", rename_all = "lowercase")]
enum Kind {
    Foo(u64),
    Bar(bool),
}

common,kind,parameter
1,foo,42
2,bar,true

1.0.161

Improve error messages produced by serde_test on test failure (#2435, thanks @Mingun)

1.0.160

Make derived serializer/deserializer internals doc(hidden) (#2426, thanks @compiler-errors)

1.0.159

Accept empty #[serde()] attribute (#2422)

1.0.158

Fix "expected serde crate attribute to be a string" error when using macro_rules metavariable inside of serde attribute: #[serde(crate = $serde_path)] (#2409)

1.0.157

Update syn dependency to 2.x

1.0.156

Documentation improvements

1.0.155

Support Serialize and Deserialize impls for core::ffi::CStr and alloc::ffi::CString without "std" feature (#2374, thanks @safarir)

1.0.154

Fix "undeclared lifetime" error in generated code when deriving Deserialize for an enum with both flatten and 'static fields (#2383, thanks @Mingun)

1.0.153

Support serde(alias = "…") attribute used inside of flattened struct (#2387, thanks @bebecue)

1.0.152

Documentation improvements

1.0.151

Update serde::{ser,de}::StdError to re-export core::error::Error when serde is built with feature="std" off and feature="unstable" on (#2344)

1.0.150

Relax some trait bounds from the Serialize impl of HashMap and BTreeMap (#2334)
Enable Serialize and Deserialize impls of std::sync::atomic types on more platforms (#2337, thanks @badboy)

1.0.149

Relax some trait bounds from the Serialize impl of BinaryHeap, BTreeSet, and HashSet (#2333, thanks @jonasbb)

1.0.148

Support remote derive for generic types that have private fields (#2327)

1.0.147

Add serde::de::value::EnumAccessDeserializer which transforms an EnumAccess into a Deserializer (#2305)

1.0.146

Allow internally tagged newtype variant to contain unit (#2303, thanks @tage64)

1.0.145

Allow RefCell<T>, Mutex<T>, and RwLock<T> to be serialized regardless of whether T is Sized (#2282, thanks @ChayimFriedman2)

1.0.144

Change atomic ordering used by Serialize impl of atomic types to match ordering used by Debug impl of those same types (#2263, thanks @taiki-e)

1.0.143

Invert build.rs cfgs in serde_test to produce the most modern configuration in the default case (#2253, thanks @taiki-e)

1.0.142

Add keywords to crates.io metadata

1.0.141

Add no-std category to crates.io metadata

1.0.140

Invert serde_derive cfgs to convenience non-Cargo builds on a modern toolchain (#2251, thanks @taiki-e)

1.0.139

Add new constructor function for all IntoDeserializer impls (#2246)

1.0.138

Documentation improvements

1.0.137

Update documentation links to some data formats whose repos have moved (#2201, thanks @atouchet)
Fix declared rust-version of serde and serde_test (#2168)

1.0.136

Improve default error message when Visitor fails to deserialize a u128 or i128 (#2167)

1.0.135

Update discord channels listed in readme

1.0.134

Improve error messages on deserializing NonZero integers from a 0 value (#2158)

1.0.133

Optimize deserialization of data structures that contain recursive use of flatten fields or tag or untagged enums (#2148)

1.0.132

Enable Serialize and Deserialize impls for std::sync::atomic::{AtomicI64, AtomicU64} on riscv64 arch (#2141, thanks @Avimitin)

1.0.131

Avoid unused_results being triggered in generated code for adjacently tagged enum (#2116, thanks @tyranron)

1.0.130

Provide MapAccess and SeqAccess impl for reference to a dynamically sized existing impl (#2081)

1.0.129

Support deserialization of remote structs that used packed repr (#2078, #2079, #2080)

1.0.128

Enable 128-bit integers on emscripten in Rust 1.40+ (#2076, thanks @Manishearth)

1.0.127

Resolve warning in rustc nightly-2021-07-31+ compiling serde_test

1.0.126

Resolve conflict with forbid(future_incompatible) lint setting in generated code (#2026, thanks @hyd-dev)

1.0.125

Improve performance of serializing Ipv4Addr (#2001, thanks @saethlin)

1.0.124

Fix possible panic deserializing invalid data as SystemTime (#1997, thanks @cyang1)

1.0.123

Support Self keywords in fields of types that derive Deserialize (#1830, thanks @taiki-e)
Allow floats to be deserialized from ints in tagged unions (#1842, thanks @Timmmm)
Support Self inside fields that use serialize_with (#1970)

1.0.122

Add IntoDeserializer impl for &[u8] (#1898, thanks @Mingun)
Handle unrecognized numeric field keys during deserialization of a field_identifier, equivalently to string field keys (#1914, thanks @Mingun)

Add attribute to override default deserialization failure expectation message (#1916, thanks @Mingun)

#[derive(Deserialize)]
#[serde(untagged, expecting = "single version or array of versions")]
struct VersionSpec {
    One(Version),
    Many(Vec<Version>),
}

Improve serde_test handling of map entries and error message construction (#1918, thanks @Mingun)
Produce more accurate location information on test failures from serde_test crate (#1920, thanks @Mingun)
Improve diagnostic on failure to parse a rename_all attribute (#1960, #1961)
Eliminate unnecessary trait bounds on some value Deserializer impls (#1963)

1.0.121

Support borrowed data during deserialization of a field identifier (#1917, thanks @Mingun)
Fix panic when deserializing Duration with nanoseconds that cause the seconds counter to overflow (#1958, thanks @jonasbb)

1.0.120

Fix deserialization of ignored fields containing 128-bit integer (#1955, thanks @TheJokr)

1.0.118

Support serialization of core::num::Wrapping in no_std mode (#1926, thanks @attente)

1.0.117

Allow serialization of std::net::SocketAddrV6 to include a scope id if present (based on https://github.com/rust-lang/rust/pull/77426)

1.0.116

Fix deserialization of IpAddr, SocketAddr, Bound, Result, OsString in formats which process variant identifiers as u64 (#1888, thanks @joshtriplett)

1.0.115

Support #[serde(flatten)] on a field whose type is a type parameter and concrete type is () (#1873)

1.0.114

Improve packed repr matching to support deriving Serialize for structs having repr(C, packed) (#1813, thanks @TannerRogalsky)

1.0.113

Improve diagnostic when a serde trait is not implemented (#1827, thanks @taiki-e)

1.0.112

Support serde(flatten) on map types where the Serializer only works with serialize_entry (#1837)

1.0.111

Process borrowed lifetimes inside of interpolated macro_rules metavariables, such as in the case of #[derive(Deserialize)] struct S<'a> { field: $field } (#1821)

1.0.110

Support deriving Serialize impl for a repr(packed) struct (#1791, thanks @alvardes)

1.0.109

Allow adjacently tagged newtype variants containing Option to omit the content field when deserializing (#1553, #1706, thanks @zth0)
Avoid panicking when a SystemTime older than UNIX_EPOCH is serialized (#1702, thanks @hjiayz)

1.0.108

Provide a Serializer impl that can write primitives and unit variants to a &mut fmt::Formatter (#1705, thanks @jethrogb)

use serde::Serialize;
use std::fmt::{self, Display};

#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum MessageType {
    StartRequest,
    EndRequest,
}

impl Display for MessageType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.serialize(f)
    }
}

1.0.107

Fix panic during macro expansion when using serde(skip) and serde(other) in the same enum (#1804)

1.0.106

Hide dummy const implementation detail from rustdoc when documenting a binary crate (#1768, thanks @robo9k)

1.0.105

Allow #[serde(borrow)] to work on non-standard Cow types (#1754, thanks @maciejhirsz)

1.0.104

Revert stabilization of Serialize/Deserialize impls for ! to account for https://github.com/rust-lang/rust/pull/67224

1.0.103

Support deserializing untagged unit variants from formats that treat unit as None (#1668)

1.0.102

Support deserializing PathBuf from bytes like &Path already did, and support deserializing Box<Path> (#1656, thanks @heftig)

1.0.101

Report errors on malformed serde attributes, like #[serde(rename =)] -- the compiler used to reject these itself, but when the compiler relaxed its requirements on attribute syntax these malformed attributes began silently being ignored by serde_derive
Eliminate unused variable warning when using skip_serializing inside a tuple variant of an adjacently tagged enum (#1617, thanks @arilotter)
Support skip attribute inside of newtype variants (#1622, thanks @Xaeroxe)

1.0.100

Provide serde::ser::StdError and serde::de::StdError which are either a re-export of std::error::Error (if Serde's "std" feature is enabled) or a new identical trait (otherwise).
```
#[cfg(feature = "std")]
pub use std::error::Error as StdError;

#[cfg(not(feature = "std"))]
pub trait StdError: Debug + Display {
    fn source(&self) -> Option<&(StdError + 'static)> { None }
}
```
Serde's error traits serde::ser::Error and serde::de::Error require std::error::Error as a supertrait, but only when Serde is built with "std" enabled. Data formats that don't care about no_std support should generally provide their error types with a std::error::Error impl directly:
```
#[derive(Debug)]
struct MySerError {...}

impl serde::ser::Error for MySerError {...}

impl std::fmt::Display for MySerError {...}

// We don't support no_std!
impl std::error::Error for MySerError {}
```
Data formats that do support no_std may either have a "std" feature of their own as has been required in the past:
```
[features]
std = ["serde/std"]
```
```
#[cfg(feature = "std")]
impl std::error::Error for MySerError {}
```
... or else now may provide the std Error impl unconditionally via Serde's re-export:
```
impl serde::ser::StdError for MySerError {}
```

1.0.99

Update Syn dependency to 1.0.

Note: This raises the minimum required compiler version for serde_derive from rustc 1.15 to rustc 1.31. The minimum required compiler version for serde remains at rustc 1.13.

1.0.98

Add support for NonZeroI* types (#1589, thanks @Flaise)

1.0.97

Introduce serde(try_from = "...") attribute to derive Deserialize based on a given implementation of std::convert::TryFrom (#1526, thanks @fanzeyi)

#[derive(Deserialize)]
#[serde(try_from = "u32")]
enum N {
    Zero,
    One,
    Two,
}

impl TryFrom<u32> for N {
    type Error = String;

    fn try_from(u: u32) -> Result<Self, Self::Error> {
        match u {
            0 => Ok(Self::Zero),
            1 => Ok(Self::One),
            2 => Ok(Self::Two),
            other => Err(format!("out of range: {}", other)),
        }
    }
}

1.0.96

Implement serialization and deserialization for std::sync::atomic types (#1572 and #1581, thanks @Roguelazer)
Make "alloc" feature work on stable Rust 1.36+ (#1576, thanks @c410-f3r)

1.0.95

yanked

1.0.94

Accept enums in input data when deserializing IgnoredAny (#1558)

1.0.93

Allow integer keys in untagged flattened map (#1545)

1.0.92

Support using serde(flatten) in no_std + alloc mode (#1543, thanks @jplatte)

1.0.91

Support deserializing from MapAccessDeserializer into an enum (#1522)

1.0.90

Add an attribute #[serde(crate = "path::to::serde")] which replaces the use of extern crate serde in the generated code; this is intended for crates that invoke Serde derives from a macro and need to refer to serde through their own re-export rather than requiring callers to list Serde in Cargo.toml (#1499, thanks @sgrif)
```
#[derive(Deserialize)]
#[serde(crate = "__tw::codegen::serde")]
struct S { ... }
```
```
// expands to:
impl<'de> __tw::codegen::serde::Deserialize<'de> for S {
    ...
}
```

1.0.89

Implement Serialize and Deserialize for core::cmp::Reverse<T> (#1486, thanks @vorot93)
Fix a Clippy lint triggered within generated code involving flatten + deny_unknown_fields (#1492, thanks @thomaseizinger)

1.0.88

Support flatten and skip_serializing / skip_deserializing attributes on the same field

1.0.87

Fix inclusion of tag in struct containing flattened fields (#1468, thanks @jwillbold)

1.0.86

Implement Serialize and Deserialize for core::ops::Bound<T> (#1466, thanks @0nkery)

1.0.85

Accept #[serde(alias = "...")] attribute on fields and variants which allows the same field or variant to be deserialized from any of multiple different names in the input (#1458, thanks @Lymia)
```
#[derive(Deserialize)]
struct S {
    #[serde(alias = "old_name")]
    new_name: String,  // will deserialize from either of "old_name" or "new_name"
}
```

1.0.84

Update example code in documentation to 2018 edition

1.0.83

Support a rename_all specification that applies only to the Serialize impl or only to the Deserialize impl (#1447, thanks @vincascm)

#[derive(Serialize, Deserialize)]
#[serde(rename_all(
    serialize = "camelCase",
    deserialize = "SCREAMING_SNAKE_CASE",
))]
struct S { /* ... */ }

Allow serializing struct name inside of structs with named fields (#1448, thanks @motu42)

#[derive(Serialize)]
#[serde(tag = "type")]
struct S { /* ... */ }  // serializes as {"type":"S",...}

1.0.82

Support serde(default) attribute inside of tuple structs and tuple variants (#1442, thanks @tcr)

1.0.81

Better error messages when using an invalid combination of serde attributes (#1424, thanks @hcpl)
Support deserializing tagged enums inside of untagged enums in formats that encode tagged enum variants by index, like MessagePack (#1437, thanks @daboross)

1.0.80

Performance optimization for Vec::deserialize_in_place to deserialize elements in place (#1411)

1.0.79

Add serde(other) variant attribute for deserializing any variant that is not one of the others (#1382)
```
#[derive(Deserialize)]
#[serde(tag = "variant")]
enum MyEnum {
    A(ModelA),
    B(ModelB),
    #[serde(other)]
    Unknown,
}
```
In this internally tagged enum the MyEnum::Unknown variant would be produced if the "variant" tag in the input is neither "A" nor "B".

This feature is currently limited to externally tagged and adjacently tagged enums in which the other variant is a unit variant.

1.0.78

Fix panic deserializing flattened Value after flattened struct (#1379)

1.0.77

Fix internally tagged enum deserialization with unknown fields (#1376, thanks @dreid)

1.0.76

Provide impls for NonZeroU128 (#1371, thanks @hcpl)

1.0.75

Adjust dependency version requirement to support building with -Z minimal-versions in CI (#1367)

1.0.74

Disable i128 integers on Emscripten targets (#1365, thanks @koute)

1.0.73

Fix the names of serialized fields when the Rust data structure uses a raw identifier (#1362)

1.0.72

Fix compilation of default-features = false, features = ["alloc", "rc"] feature combination (#1359, thanks @Pratyush)

1.0.71

Provide impls for core::ops::RangeInclusive (#1347, thanks @c410-f3r)
Provide impls for core::ops::Range whether or not "std" feature is enabled (#1348)

1.0.70

Update --features alloc to work with nightly-2018-07-07 (#1335)

1.0.69

Support Rust 2018 use_extern_macros (https://github.com/rust-lang/rust/pull/51496)

1.0.68

Suppress 'extern crate' warning for rust 2018 (#1324, thanks @jechase)

1.0.67

Implement Serialize for core::fmt::Arguments (#1319)

1.0.66

Implement Serialize and Deserialize for ! (#544, unstable)
Support Duration in no-std mode on sufficiently new compilers (#1123)
Improve compiler error messages (#1297, thanks @adamcrume)

1.0.65

Do not panic when serializing a RefCell that is currently mutably borrowed (#1300, thanks @xfix)
Allow flattened fields after a flattened map to receive input fields (#1299)

1.0.64

Second attempt to work around docs.rs old compiler version (#1295)

1.0.63

Workaround to get docs.rs successfully building our docs with its old compiler (#1294)

1.0.62

Implement IntoDeserializer for i128 and u128 (#1280)
Implement Copy for the primitive value deserializers (#1287)
Implement Clone for primitive value deserializers even when the error type cannot be cloned (#1287)

1.0.61

Stabilize Deserialize impls for dynamically sized Rc / Arc (#1266)
Stabilize Deserialize impl for Box<CStr> (#1267)

1.0.60

Add Serde impls for i128 and u128 when compiling with Rust 1.26+ (#1263)
Stabilize Serde impls for std::num::NonZero* on Rust 1.28+ (#1278, thanks @SimonSapin)

1.0.59

Add a serde(transparent) container attribute to indicate that a struct serializes and deserializes the same as its only field -- analogous to repr(transparent) (#1054)

1.0.58

Fix generated code for deserializing untagged newtype variant (#1268)

1.0.57

Remove unstable Serialize and Deserialize impls for NonZero<T> which has been removed from the most recent nightly compiler (#1265)

1.0.56

Add a Serde build.rs script for rustc version detection in preparation for adding i128 / u128 primitive support on sufficiently new compilers. Please let us know in #1136 if having a build script causes undue complication in your environment. We will begin using the build script to enable observable functionality after a week or so, at which point it will become harder to roll back.

1.0.55

Support formats that want to deserialize flattened identifiers as bytes (#1257)

1.0.54

Support flattened untagged Options in struct fields (#1255)

1.0.53

Support deserializing flattened untagged enum (#1253)

1.0.52

Allow overriding inferred bounds at the variant level using a bound attribute (#1149)
Respect skip_serializing attribute in tuple structs and variants (#1048)
Account for skip_serializing_if in computing tuple struct lengths (#1049)
Improve error for struct deserialized from array that is too short (#981)
Accept implicitly borrowed data inside of an Option field (#1029)

1.0.51

Fix the Deserialize implementation generated for an adjacently tagged enum with zero variants (#785)
Improve error message when deriving Deserialize for a type that already has a 'de lifetime (#893)
Add a #[serde(skip)] variant attribute to combine the skip_serializing and skip_deserializing variant attributes that already existed
Respect variant skip attributes when inferring type parameter bounds (#892)

1.0.50

Detect unsupported use of Deserialize on a dynamically sized struct ending in slice field (#830)

1.0.49

Add serialize and deserialize impls for std::rc::Weak and std::sync::Weak (#1251)

1.0.48

Fix Serialize impl of an adjacently tagged empty tuple variant or struct variant (#1247)

1.0.47

Support flatten attribute inside of enums (#1206)

1.0.46

Support deserializing a flattened internally tagged enum (#1189)

1.0.45

Fix dead code warnings when generating remote impls (#976)

1.0.44

Respect deserialize_with used together with flatten (#1240)

1.0.43

Fix handling of newtype struct inside of an untagged enum in serde_test (#1233)

1.0.42

Optimizations for binary size (#1227, #1228, #1229)

1.0.41

Allow integers in an internally tagged enum to be deserialized from CBOR integers of any size (#1222)

1.0.40

More flexible deserialization of byte arrays inside of untagged and internally tagged enums (#1217, #1216)

1.0.39

Implement deserializer hints in handling of untagged and adjacently tagged enums to improve compile time and executable size (#286)

1.0.38

Infer trait bounds for use of a type parameter associated type (#1213, thanks @Osspial)
Fix deserialize_with on a struct variant with one field (#1215)

1.0.37

Better error messages for unsupported uses of serde(flatten) (#1204 and #1205, thanks @mitsuhiko)

1.0.36

Emit working code in the case of remote = "Self" attribute (#1196)

1.0.35

Implement Serialize and Deserialize for unsigned std::num::NonZero* types (#1191, tracking issue https://github.com/rust-lang/rust/issues/49137, thanks @SimonSapin)

1.0.34

Add a flatten attribute to remove one level of structure between the serialized representation and the Rust data structure; more details in struct flattening (#1179, thanks @mitsuhiko)

1.0.33

Fix parsing of Self-qualified paths like "<[_]>::serialize" within serialize_with attributes

1.0.32

Fix derive expansion for structs containing &str or &[u8] with missing lifetime parameter (#1176)

1.0.31

(yanked)

1.0.30

Fix borrowed Cow<[u8]> deserializing from non-UTF8 bytes (#1175, thanks @daboross)

1.0.29

Fix unused parentheses warning in generated code (#1172)

1.0.28

Update to Syn 0.12 which allows serde_derive to handle new Rust syntax that has been added within the past year
Report conflicts between the tag of an internally tagged enum and any of the variant field names, or between the tag and content field of an adjacently tagged enum (#1170, thanks @H2CO3)

1.0.27

Add "UPPERCASE" option to #[serde(rename_all = "...")] (#1132, thanks @Lireer)

1.0.26

Extend Serialize and Deserialize impls on PhantomData to work for T: ?Sized

1.0.25

Add the following function with default implementation to the Deserialize trait (thanks @Gankro!)

fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
where
    D: Deserializer<'de>,
{
    *place = Deserialize::deserialize(deserializer)?;
    Ok(())
}

This is a power user feature that allows deserialization to reuse existing allocations for types like String and Vec. Enable the deserialize_in_place feature of serde_derive to generate these efficient implementations for all types that use #[derive(Deserialize)].

extern crate serde;
extern crate serde_json;

use serde::Deserialize;

fn main() {
    let mut v = Vec::<i32>::with_capacity(128);
    assert_eq!(v.capacity(), 128);

    let j = "[1, 2, 3]";
    let ref mut de = serde_json::Deserializer::from_str(j);
    Deserialize::deserialize_in_place(de, &mut v).unwrap();
    assert_eq!(v, [1, 2, 3]);
    assert_eq!(v.capacity(), 128);
}

1.0.24

Fix delegation of a skipped field's default value to the container's Default impl (#1105, thanks @Binero)
Improve performance of array deserialization (#1106, thanks @khuey)

1.0.23

Revert a change that caused serde_test deserialization tests using skipped fields to fail (#1096)

1.0.22

Fix #[derive(Deserialize)] used with #![no_implicit_prelude] (#1103)

1.0.21

Fix deserialization of untagged newtype variant containing externally tagged struct variant in formats that represent struct variants as a sequence (#1093, thanks @alex-shapiro)

1.0.20

Print the contents of the expected token when a serialize assert fails (#1086, thanks @Marwes)
Catch wrong field names length in serde_test (#1090)

1.0.19

Allow borrow attribute on newtype variants (#929)
Fix bounds for macro named the same as a type parameter (#1081)
Add an API for making tests for readable/compact representations (#1084, thanks @Marwes)
Allow internally tagged newtype variant containing unit struct (#1085)

1.0.18

Fix handling of borrowed lifetimes in fields that are skipped during deserialization (#1078, thanks @epage)

1.0.17

Add impls for std::num::Wrapping (#1072, thanks @LinearZoetrope)

1.0.16

Add Serializer::is_human_readable and Deserializer::is_human_readable which allow types like IpAddr to serialize in a human-readable representation in formats like JSON but in a compact binary representation in formats like Bincode (#1044, thanks @Marwes)

1.0.15

Support for deserializing internally tagged enums in MessagePack (#1058)

1.0.14

Generate code without warnings when a struct contains a &'static field (#1052)
Fix errors in generated code when compiling with deny(trivial_numeric_casts) (#1053)

1.0.13

Allow the tag of a field or enum variant to be deserialized from any unsigned integer type (#963, thanks @sfackler)
Support serialize_with and deserialize_with applied to entire enum variants (#1015, thanks @spinda)
Add an optional skip_field method so serializers can be notified when a field is skipped (#1022, thanks @sfackler)
Add a "SCREAMING-KEBAB-CASE" option for the rename_all attribute (#1043, thanks @greyblake)

1.0.12

Implement Serialize for Rc<T> and Arc<T> where T: ?Sized (#1038)
Implement Deserialize for Rc<T> and Arc<T> where Box<T>: Deserialize (#1039)

1.0.11

Make remote derive usable from outside of the module containing the remote definition (#1001)
Update NonZero deserialization to account for constructor changes in nightly (#1003)

1.0.10

Implement Serialize and Deserialize for std::time::SystemTime (#949, thanks @WiSaGaN)

1.0.9

Fix inferred Deserialize bounds in remote derive (#972)
Combine the unstable collections and alloc features to align with https://github.com/rust-lang/rust/pull/42648

1.0.8

Add a #[serde(skip)] field attribute which unifies skip_serializing and skip_deserializing (#935, thanks @spikefoo)

1.0.7

Add BorrowedStrDeserializer and BorrowedBytesDeserializer which act like IntoDeserializer implementations for &'de str and &'de [u8] (#940, thanks @BurntSushi)

1.0.6

~~Add a #[serde(skip)] field attribute which unifies skip_serializing and skip_deserializing (#935, thanks @spikefoo)~~ (mistakenly omitted from 1.0.6, this feature is in 1.0.8)

1.0.5

Fix a regression in deserializing internally tagged struct variants containing unit variant containing borrowed strings (#932)

1.0.4

Support borrowing within internally tagged enum (#926)

1.0.3

Implement Deserialize for &std::path::Path (#924, thanks @pshc)

1.0.2

Make adjacently tagged enums honor deny_unknown_fields (#905, thanks @TedDriggs)

1.0.1

Remove usage of unstable core::num::Zero, which was removed upstream (#898, thanks @SimonSapin)

1.0.0

[Serde website] [API documentation]

The primary focus of this release is on polish: making Serde easier to learn and more enjoyable to use. That said, this wouldn't be Serde without some amazing new features to tell you about as well.

In celebration of this milestone, I would like to highlight some of the work that has contributed toward making Serde the powerful, efficient, adaptable, convenient beast that exists today. This is the unfinished history of serialization in Rust.

March 2011 — Patrick Walton adds support for serializing Rust object metadata into a format called EBML (reader and writer).
November 2011 — Elly Jones adds a JSON library called std::json.
February 2012 — Niko Matsakis creates a utility to generate serialization code for data structures, eliminating the grunt work of writing it by hand. The first serializer and deserializer traits appear. The same traits still exist practically unchanged in rustc_serialize today.
May 2014 — Erick Tryzelaar begins Serde, exploratory work to address some severe, foundational limitations in the standard library's approach to deserialization.
December 2014 — Alex Crichton begins the deprecation of libserialize. It is clear that the design has a number of drawbacks, and there aren't resources to address them in time for Rust 1.0. The code is moved out of the rustc codebase into the rustc_serialize crate.
March 2015 — Erick Tryzelaar releases Serde 0.2.0, proving decisively that the limitations in libserialize can be resolved by a better approach.
May 2015 — Rust 1.0 is released. :cake:
April 2017 — Serde is impressively fast, battle-tested in production use cases, and ready for a solid 1.0 release.

Thank you to more than 100 people who have contributed improvements, opened issues, provided help to others, or expressed their frustrations with Serde in a constructive way. We appreciate your continued support.

Zero-copy deserialization

Serde 1.0 adds the ability to deserialize into types that borrow from the input data. For example, this JSON document can now be deserialized efficiently and safely into the following Rust struct.

{
    "fingerprint": "0xF9BA143B95FF6D82",
    "location": "Menlo Park, CA"
}

#[derive(Deserialize)]
struct User<'a> {
    fingerprint: &'a str,
    location: &'a str,
}

The value for each field will be a string slice that refers to the correct substring of the input data. No memory is allocated for the strings and no data is copied. The same thing also works for &[u8] slices. Other types can be borrowed explicitly by using the #[serde(borrow)] attribute.

This uniquely Rust-y feature would be impossible or recklessly unsafe in languages other than Rust. The semantics of Rust guarantee that the input data outlives the period during which the output struct is in scope, meaning it is impossible to have dangling pointer errors as a result of losing the input data while the output struct still refers to it.

Zero-copy deserialization is discussed in more detail on this page of the website.

Remote derive

One recurrent struggle with Serde is needing to use types from somebody else's crate where they do not provide Serialize and Deserialize impls.

Rust's "orphan rule" allows writing a trait impl only if either your crate defines the trait or defines one of the types the impl is for. That means if your code uses a type defined outside of your crate without a Serde impl, you resort to newtype wrappers or other obnoxious workarounds for serializing it.

Serde 1.0 now supports deriving impls for structs and enums defined in other people's crates.

// Serde calls this the definition of the remote type. It is just a copy of the
// remote type. The `remote` attribute gives the path to the actual type.
#[derive(Serialize, Deserialize)]
#[serde(remote = "nifty::Duration")]
struct DurationDef {
    secs: i64,
    nanos: i32,
}

// Now the remote type can be used almost like it had its own Serialize and
// Deserialize impls all along. The `with` attribute gives the path to the
// definition for the remote type. Note that the real type of the field is the
// remote type, not the definition type.
#[derive(Serialize, Deserialize)]
struct Process {
    command_line: String,

    #[serde(with = "DurationDef")]
    wall_time: nifty::Duration,
}

Remote derive is covered on this page of the website, which also includes an example of handling a remote struct with private fields.

Documentation

Lots of new content on the Serde website. The following new pages in particular are a valuable read even for experienced Serde users.

The Serde data model — A new way of conceptualizing Serde's role in the ecosystem and its type system.
Understanding deserializer lifetimes — Helpful reference as you work to upgrade your libraries to Serde 1.0.
Writing a data format — A complete serializer and deserializer implementation annotated with an explanation of all the pieces.

Is Serde done?

As of this release, Serde is stable but not done. We say with confidence that Serde is the best serialization solution that we can design for the Rust language as it exists today and for the broad range of use cases that we target.

The Serde issue tracker has a long list of planned enhancements for you to look forward to and maybe help us implement. For the first time, none of them involve further breaking changes.

Breaking changes

Zero-copy deserialization involves tracking a 'de lifetime.

The Deserialize and Deserializer traits as well as some other deserialization-related traits now have a 'de lifetime parameter. These lifetimes enable Serde to perform efficient and safe zero-copy deserialization across a variety of data formats. The website has a page on understanding deserializer lifetimes.
Method Deserializer::deserialize has been renamed to deserialize_any.

The old name did nothing to clarify the purpose of this method in contrast to any of the other Deserializer trait methods. Also the existence of a method named deserialize on two different Serde traits sometimes required them to be explicitly disambiguiated using UFCS.
Deserializer-provided accessor traits have been renamed.

The SeqVisitor, MapVisitor, EnumVisitor, and VariantVisitor traits have been renamed to SeqAccess, MapAccess, EnumAccess, and VariantAccess. The old names conflicted with the Visitor trait which plays a totally different role, and this was a source of confusion for new and even experienced Serde users. What's more, these accessor traits were never really playing the role of a visitor in any common sense. The are provided by the Deserializer to a Visitor to give it the ability to access elements of a data structure.
Some questionable implicit type conversions are gone.

For example, a JSON null will no longer successfully deserialize if the output type is a string. Such conversions violated the objective that if Serde successfully deserializes some input into a particular data structure, you can be condient that the input matches what your data structure says it should look like.
ValueDeserializer has been renamed to IntoDeserializer.

The new name aligns with traits that play a similar role in other parts of the Rust ecosystem, such as IntoIterator and IntoFuture.
The concept of a fixed-size sequence is gone in favor of tuple.

Previous versions of Serde represented fixed-size arrays like [u64; 3] and tuples like (u64, u64, u64) as different types in the data model. From the perspective of a Serde data format the distinction between these types never matters, so fixed-size sequences have been removed from the data model.
Method deserialize_struct_field has been renamed to deserialize_identifier.

This method has existed since Serde 0.7 but has always been used for both struct fields and enum discriminants. The new name reflects that this method is used to identify what to deserialize next—whether that is to decide which field of a struct we are looking at, or which variant of an enum.
Variant indices during deserialization have changed from usize to u32.

Previous versions of Serde treated the index of a variant in an enum as usize while serializing and as u32 while deserializing. This inconsistency has been resolved by standardizing on u32.
The serde_test Token API has been redesigned.

The serde_test crate is great for unit testing implementations of Serialize and Deserialize without being tied to any particular data format. The API had stagnated over the past few releases so this redesign brings it in line with modern naming conventions and Serde concepts.
Built-in visitors are private.

The Visitor implementations used for deserializing standard library types have been made private. These are an implementation detail and were not designed to be used by other crates.
Byte-related wrapper types have moved to the serde_bytes crate.

The Bytes and ByteBuf wrappers are a stopgap solution until specialization enables us to handle &[u8] and Vec<u8> in an optimized way by default.
Size hint methods have changed from (lower, upper) bounds to Option<usize>.

The size hint on the standard library Iterator trait returns lower and upper bounds in order to optimize handling of complicated iterator chains. This use case never arises during Serde deserialization; the deserializer either knows the exact length of a sequence or map or has no idea.
Rc and Arc impls require opting in to a feature.

Serialization of the reference-counted types Rc<T> and Arc<T> was a source of confusion. A single Rc could be serialized multiple times as part of a data structure, then deserialize to multiple copies of itself. If this is the behavior you want, opt in to these impls by enabling the "rc" feature of your Serde dependency.

0.9.15

Remove usage of unstable core::num::Zero, which was removed upstream (#899, thanks @SimonSapin)

0.9.14

Implement Serialize and Deserialize for Cell<T>, RefCell<T>, Mutex<T>, RwLock<T> (#882, thanks @jethrogb)

0.9.13

Support deserializing OsString on Windows (#838)

0.9.12

Add #[serde(into = "T")] to serialize using the implementation of Into<T> and #[serde(from = "T")] to deserialize using the implementation of From<T> (#817, thanks @jbaublitz)
```
#[derive(Serialize, Deserialize)]
#[serde(into = "u32", from = "u32")]
struct Ipv4Addr {
    /* ... */
}
```
Implement Deserialize for Box<CStr> on nightly (#811, thanks @jonhoo)
Implement Serialize and Deserialize for OsString and implement Serialize for OsStr (#824, thanks @alexcrichton)
Implement Serialize for Range (#813, thanks @rocallahan)

0.9.11

Implement Serialize and Deserialize for CString and implement Serialize for CStr (#801, thanks @jonhoo)
Provide Serializer::collect_str to enable zero-allocation serialization of dynamically constructed strings (#789, thanks @nox)

0.9.10

Add a rename_all attribute to rename all the fields of a struct or struct variant, or all the variants of an enum.
```
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct S {
    first_field: u8, // gets renamed to firstField
    second_field: u8, // gets renamed to secondField
}
```
The possible renames are:
- #[serde(rename_all = "PascalCase")]
- #[serde(rename_all = "camelCase")]
- #[serde(rename_all = "snake_case")]
- #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
- #[serde(rename_all = "kebab-case")]

0.9.9

Fix a bug causing externally tagged enums inside of untagged / internally tagged enums to fail to deserialize (#775 and https://github.com/serde-rs/json/issues/248)

0.9.8

Add with = "..." attribute that serves as a combination of serialize_with and deserialize_with (#763)

 #[derive(Serialize, Deserialize)]
 struct MyStruct {
-    #[serde(serialize_with = "hyper_serde::serialize",
-            deserialize_with = "hyper_serde::deserialize")]
+    #[serde(with = "hyper_serde")]
     headers: Headers,
 }

Whatever path you give, Serde will use $path::serialize as the serializer and $path::deserialize as the deserializer.

Haskell / Pandoc style adjacently tagged enums (#758, thanks @elliottslaughter)

#[derive(Serialize, Deserialize)]
#[serde(tag = "t", content = "c")]
enum MyType {
    One(String),
    Two(u8, u8),
}

Written in JSON syntax, this enum would be represented as:

{ "t": "One", "c": "whatever string" }
{ "t": "Two", "c": [127, 1] }

Allow serde(default) attribute on structs (#780, thanks @Thomasdezeeuw)

#[derive(Serialize, Deserialize)]
#[serde(default)]
struct StructDefault {
    a: i32,
    b: String,
}

impl Default for StructDefault {
    fn default() -> Self {
        StructDefault {
            a: 100,
            b: "default".to_string(),
        }
    }
}

Clamp size hints coming from untrusted input to 4096 (#774, thanks @nox)

This mitigates some types of attacks where untrusted input can instigate the allocation of large vectors or maps.
Optimize the serialization of various std::net types (#778, thanks @SimonSapin)

0.9.7

Add Serializer::collect_seq and Serializer::collect_map to simplify some Serialize impls (#736)

- let mut map = serializer.serialize_map(Some(self.len()))?;
- for (k, v) in self {
-     map.serialize_key(k)?;
-     map.serialize_value(v)?;
- }
- map.end()
+ serializer.collect_map(self)

0.9.6

Support for untagged and internally tagged enum representations; see the manual for details (#739)
Remove Serialize and Deserialize impls for collections::enum_set::EnumSet which has been deprecated for a long time (#740)
Fix compilation errors in generated code when Ok or Err were redefined from their usual meaning within the same module (#737)

0.9.5

Remove clippy dependency to unblock the documentation build in docs.rs

0.9.4

Provide serde::ser::Impossible, a helper for Serializer implementations that do not support serializing one of the compound types (#694)

0.9.3

Fix invalid-length error message for arrays and tuple that incorrectly claimed the length was always 0

0.9.2

Add SerializeMap::serialize_entry to allow serializers to optimize for the case where key and value are both available at the same time (#724)

0.9.1

Bump the serde dev-dependency on serde_derive - see this forum thread

0.9.0

In the six months since Serde 0.8.0 we have learned a lot about how people use Serde, how people wish they could use Serde, and the common failure modes when people try to use Serde.

The primary focus of 0.9.0 is on using Rust's type system to enforce contracts that were implicit and fragile in previous Serde versions. All four of the Serialize, Deserialize, Serializer, and Deserializer traits have been redesigned to use ownership as a way to enforce that implementations are correct.

Another exciting improvement is a redesigned error-reporting API that produces substantially more helpful error messages. The new API supports no_std as a first-class citizen, meaning no_std users are now able to receive the same helpful messages as std. Speaking of no_std, #[derive(Serialize, Deserialize)] now works within no_std crates.

Serde 0.9.0 is a huge release compared to previous ones. Thank you to dozens of people who have contributed improvements, opened issues, provided help to others, or expressed their frustrations with Serde in a constructive way. We appreciate your continued support as we pin down what a 1.0.0 data structure serialization library for Rust should look like.

This release includes serde_codegen for Rust 1.14 and earlier users. With Macros 1.1 custom derives being stabilized next week in Rust 1.15, we will not be releasing any further 0.9.x versions of serde_codegen. Please migrate to serde_derive at your convenience. See the manual for steps.

There are no silent breaking changes in this release. As you work to update your libraries, the compiler will tell you everything that needs to be changed.

Users of serde_json should read also the serde_json 0.9.0 release notes. This is a great release for serde_json, including a powerful new json! macro.

Breaking changes

The signature of Serialize::serialize has changed.
```
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-     where S: Serializer;
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+     where S: Serializer;
```
Together with the Serializer changes in this release, the new signature enforces that the implementation makes exactly one serializer method call. In previous Serde versions, an incorrect Serialize implementation could invoke the serializer not at all or more than once, resulting in a correctly-written serializer producing syntactically invalid output.

The signature of Deserialize::deserialize has changed.

- fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-     where D: Deserializer;
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+     where D: Deserializer;

Same reason as the Serialize change.

The Serializer comes with an associated type S::Ok.

All Serializer methods return this type and it is propagated by the Serialize trait as you can see above. The various Serializer methods have changed like this:
```
- fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error>;
+ fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
```
The change from &mut self to self is how the Serialize trait enforces at most one call to a serializer method, and the associated type S::Ok is how the Serialize trait enforces at least one call to a serializer method. Together these changes enforce a correct Serialize implementation.

Most serializers that produce binary or text data as output or write to a stream will want to set Ok = (). In some cases serializers that build in-memory data structures as output may benefit from using a different Ok type. For example serde_json provides a Serializer that turns a type T into serde_json::Value (this is distinct from the main serde_json Serializer that produces JSON text). This Serializer is vastly simplified by using Ok = serde_json::Value compared to its previous implementation.

The change from &mut self to self means that many Serializers will want to change their implementation from impl Serializer for SomeThing to impl<'a> Serializer for &'a mut SomeThing.
The serialization scheme for compound types has changed.

This does not affect types that use #[derive(Serialize)]. It affects types that provide custom implementations of Serialize and serialize into one of the compound types: sequence, tuple, tuple struct, tuple variant, map, struct, or struct variant.

For example to serialize a sequence type like Vec<T>:
```
- let mut seq_state = serializer.serialize_seq(Some(self.len()))?;
- for element in self {
-     serializer.serialize_seq_elt(&mut seq_state, element)?;
- }
- serializer.serialize_seq_end(seq_state)
+ let mut seq = serializer.serialize_seq(Some(self.len()))?;
+ for element in self {
+     seq.serialize_element(element)?;
+ }
+ seq.end()
```
The new scheme is more concise and uses ownership to enforce a correct implementation. It is impossible to forget to call end() because you cannot get an S::Ok instance otherwise. Previously, forgetting to call serialize_seq_end would often result in broken output from the serializer.
The pointer-sized usize and isize types are no longer part of the Serde data model.

Rust's usize and isize types are still supported but will be serialized as u64 and i64 from the perspective of a Serializer and Deserializer implementation.
The ser::Error and de::Error traits have been redesigned.

The new design is able to produce substantially more helpful error messages and supports no_std as a first-class citizen without sacrificing usability for std users.
```
- Invalid type. Expected `I64`
+ invalid type: integer `99`, expected a string

- Unknown variant `X`
+ unknown variant `X`, expected one of `A`, `B`, `C`

- Invalid length: 1
+ invalid length 1, expected a tuple of 2 elements
```
Please see the API documentation for details.
A new stateful deserialization API.

A DeserializeSeed trait has been added to handle cases where deserialization needs to depend on some pre-existing piece of state (the "seed"). One possible application of this API is for deserialization that writes into an existing previously allocated buffer rather than allocating a fresh buffer for every element. The existing buffer can be used as a "seed" that the DeserializeSeed implementation can write into.

This API dramatically simplifies serde-transcode and other streaming deserialization use cases, eliminating the need for unsafe code in many situations.

Refer to the API documentation for a complete example.
The end() method has been removed from SeqVisitor and MapVisitor.

This affects custom implementations of Deserialize that deserialize from a sequence or map type. The end() method was too easy to forget to call and it was ambiguous whether it needed to be called on various error codepaths.
The enum deserialization API has been simplified.

This affects custom implementations of Deserialize that process enum types. The new enum API is now much more similar to the sequence and map deserialization APIs and some convoluted indirection has been cleaned up.

0.8.23

Add categories to crates.io (#707, thanks @shepmaster)

0.8.22

Remove #![feature(proc_macro)] feature gates to support serde_derive on the beta channel!
Support deserializing a ByteBuf from a string (#645)

0.8.21

Implement skip_serializing for enum variants (#653, thanks @shinglyu)
```
#[derive(Serialize)]
enum E {
    A(bool),
    B(String),
    #[serde(skip_serializing)]
    C(NotSerializable),
}
```
Serialization will fail with a message if that particular variant is the one being serialized.

"The enum variant E::C cannot be serialized"

0.8.20

Implement skip_deserializing for enum variants (#641, thanks @shinglyu)

#[derive(Deserialize)]
enum E {
    A(bool),
    B(String),
    #[serde(skip_deserializing)]
    C(NotDeserializable),
}

0.8.19

Support for rustc 1.15.0-nightly (7b3eeea22 2016-11-21)

0.8.18

Support for rustc 1.15.0-nightly (ac635aa95 2016-11-18)

0.8.17

Support for rustc 1.14.0-nightly (7c69b0d5a 2016-11-01)

0.8.16

Fix possible warning when building with #![warn(unused_results)] (#599, thanks @TheCatPlusPlus)

0.8.15

Use post-expansion tricks to make serde attributes available to other custom derives like elastic_types_derive (#592)

0.8.14

Fix corrupted deserialization code being generated randomly when using serde_codegen (did not affect serde_derive) #590

0.8.13

The empty array [T; 0] now supports deserializing from formats that handle fixed-sized arrays only (#582)
The empty array [T; 0] no longer requires T: Default in order to deserialize (#583)

0.8.12

Update the serde_derive crate type from "rustc-macro" to "proc-macro" to match the blanket rename in Rust (https://github.com/rust-lang/rust/pull/36945). Rustc 1.14.0-nightly (6e8f92f11 2016-10-07) is the first version containing the rename.

0.8.11

Impl Serialize and Deserialize for IpAddr without requiring the unstable feature (#568)

0.8.10

This release deprecates the old Serde compiler plugin serde_macros in favor of the Macros 1.1-based implementation serde_derive.

We do not intend to release any further version of serde_macros, not even to fix breakage in future nightly versions. The design of Macros 1.1 is such that we do not expect to see the regular breakage with serde_derive that we used to see with serde_macros, as it depends on a far more limited set of unstable compiler internals.

See https://serde.rs/codegen-nightly.html for steps to set up serde_derive, or https://serde.rs/codegen-hybrid.html for steps to set up a hybrid serde_codegen/serde_derive approach that works on stable.

Old approach

[dependencies]
serde_macros = "0.8"

#![feature(plugin, custom_derive)]
#![plugin(serde_macros)]

New approach

[dependencies]
serde_derive = "0.8"

#![feature(rustc_macro)]

#[macro_use]
extern crate serde_derive;

// everything else is the same

0.8.9

Support for rustc 1.13.0-nightly (1265cbf4e 2016-09-15)

0.8.8

Fix faulty generated code when using a serialize_with field attribute along with a nonstandard Result type in the same module (#546)

0.8.7

Add a forward_to_deserialize! macro to simplify JSON-like Deserializer implementations that want to ignore type hints given by Deserialize (#525)

impl Deserializer for MyDeserializer {
    fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor
    {
        /* ... */
    }

    forward_to_deserialize! {
        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
        tuple_struct struct struct_field tuple enum ignored_any
    }
}

Add constructors for the Bytes and ByteBuf helpers (#520)
Allow MapDeserializer to be deserialized as a sequence of pairs instead of a map (#527)
Fix warnings in generated code for a non-unit struct with no fields (#536)
Minor cleanup of generated serialization code (#538)

0.8.6

Add a serde_derive crate which provides a Macros 1.1 implementation of #[derive(Serialize, Deserialize)] (#530)
Add serde_codegen::expand_str which is necessary for Macros 1.1

Using Macros 1.1 requires rustc support (not in nightly yet but available in https://github.com/rust-lang/rust/pull/35957) and cargo support (available in https://github.com/rust-lang/cargo/pull/3064). Using Macros 1.1 looks like this:

Cargo.toml

[dependencies]
serde = "0.8"
serde_derive = "0.8"

src/main.rs

#![feature(rustc_macro)]

#[macro_use]
extern crate serde_derive;

#[derive(Serialize, Deserialize)]
struct ItWorks {
    exciting: bool,
}

Advantages of this approach:

We expect Macros 1.1 to be stabilized much sooner than the features that serde_macros relies on, so we are finally in sight of having ergonomic Serde code generation available on stable Rust.
Even on nightly Rust, serde_derive is built in a way that is much more stable than serde_macros. It will not be affected by breaking libsyntax changes in the nightly compiler.

0.8.5

Support for rustc 1.13.0-nightly (eac41469d 2016-08-30)

0.8.4

Implement ValueDeserializer for Cow<str> (#513)
Support maps of unknown size in MapDeserializer (#514)

0.8.3

Fixes codegen for structs that have a lifetime parameter but no generic type parameter (#507)

0.8.2

Using Syntex, serde_codegen::expand now runs with a 16 MB stack by default because the previous default was often insufficient (#494, #503)

0.8.1

Impl Serialize and Deserialize for std::time::Duration (#476)
Use a thread in the build script of serde_codegen to allow env vars to control the stack size (#488)

0.8.0

This release contains significant breaking changes compared to v0.7.x.

Traits

The Serializer trait has been modified to allow for streaming serialization - serializing seq and map elements before knowing what the end of the seq or map will be. (#437)

Reduced boilerplate (no more SeqVisitor and MapVisitor) when implementing Serialize for most types.

// OLD API
struct MySeqVisitor { /* ... */ }
impl /* pages of boilerplate */
try!(serializer.serialize_seq(MySeqVisitor::new(iter, len)));

// NEW API
let mut state = try!(serializer.serialize_seq(len));
for e in iter {
    try!(serializer.serialize_seq_elt(&mut state, e));
}
try!(serializer.serialize_seq_end(state));

The Serializer and Deserializer traits no longer provide default implementations for any methods. The old defaults were JSON-centric and inappropriate for most other formats. Every Serializer and Deserializer should mindfully implement all of the methods. (#437, #452)

Codegen

No more public dependency on Syntex. The serde_codegen::register function which was deprecated in v0.7.9 has been removed. Users should use serde_codegen::expand. See the readme for sample code, and see this forum topic for exposition. (#445)
Adjusted heuristic for generating bounds on generic type parameters (#456). This fixes a number of issues relating to bounds on recursive types, bounds involving references, and bounds involving private types (#435, #436, #441, #443)

Impls

The Deserialize impl for PhantomData<T> has been expanded to all T, not just T: Deserialize (#457, #459)
Add Deserialize impl for Box<str> (#454)

Nightly

The nightly feature has been renamed to unstable to align with community practices. (#404)

0.7.15

(this release is a Syntex bump only)

0.7.14

(this release is a Syntex bump only)

0.7.13

Excludes generated code from Clippy lints (rust-clippy#969)
Fixes the error code when deserializing a struct or enum from a seq of the wrong length (#421)

0.7.12

(this release is a Syntex bump only)

0.7.11

Better error when attempting to derive Deserialize for a struct containing &str (#378)
Error when a struct field has duplicate attributes (#355)
Serialize and Deserialize impls for tuples up to 16 elements (previously only up to 12 elements) (#387)

0.7.10

Adds Serialize and Deserialize support for HashMap and HashSet that use a non-default Hasher (#369)

0.7.9

Adds serde_codegen::expand as an alternative to serde_codegen::register when using the with-syntex feature. This hides the dependency on Syntex and allows Syntex users to avoid being broken by Serde bumping its Syntex dependency. The serde_codegen::register function is deprecated and will be removed in 0.8.0. #362

0.7.8

Adds a bound attribute for specifying handwritten where clause for Serialize and Deserialize impls in tricky situations (#352)
- #[serde(bound="D: Serialize + Deserialize")]
- #[serde(bound(serialize="D: Serialize", deserialize="D: Deserialize"))]
No longer generates bounds based on fields that contain direct recursion as this typically leads to infinite recursion in rustc (#336)
Fixes rename attributes canceling one another if specified separately for ser and de (#353)

0.7.7

Reverts an unintentional breaking change in 0.7.6 (#349)

0.7.6

Enables use in no_std environments, controlled by the following feature flags (#316)
- alloc (implies nightly)
- collections (implies alloc and nightly)
- std (default)
Fixes a number of bugs around (de)serialize_with in newtype structs, tuple structs, newtype variants, and tuple variants (#335)
Serializes double-references to generic types correctly (#337)
Fixes some compiler warnings that snuck into 0.7.5 (#322)

0.7.5

Fixes a codegen regression from 0.7.4 that generates invalid code for some generic structs (#308)
Visiting the same struct field or map key twice is now an error (#293)
Fields with deserialize_with are no longer required to implement the Deserialize trait (#311)
Fixes a codegen bug related to deserialize_with in a struct containing more than one field (#308)
Fixes a codegen bug related to deserialize_with in a struct with a type parameter called D (#315)

0.7.4

Adds skip_deserializing attribute (#265)
Adds Deserialize impl for Box<[T]> (#290)
Fields with skip_serializing are no longer required to implement the Serialize trait (#260, #285)
A bound of std::default::Default is inferred for fields that use the default attribute (#285)
Supports codegen for structs that use defaulted generic type params (#295)
Supports extern crate serde not in the top-level module (#298)