serde-value

serde-value provides a Value enum that can hold any data structure serializable through Serde, capturing it as an in-memory tree for later processing. It implements both Serialize and Deserialize, so any type that works with Serde can be converted into a Value and back again without needing a concrete target type up front.

This makes it useful as an intermediate representation when the final destination type isn’t known until later — for example, deserializing a tagged payload where the variant depends on a sibling field, or writing generic middleware that inspects, transforms, or re-serializes arbitrary data before it reaches its final type.

What You Get

• Value enum - a single type covering every Serde data kind (bools, all integer widths, floats, chars, strings, unit, options, newtypes, sequences, maps, bytes) for holding arbitrary serialized data.
• to_value - converts any Serialize type into a Value tree in one call.
• Value::deserialize_into - deserializes a captured Value into any concrete Deserialize type once you know what it should become.
• ValueDeserializer - wraps a Value as a full Serde Deserializer, so it plugs into custom Deserialize impls (e.g. tag-based enum dispatch) without a crate-specific error type.

Common Use Cases

• Deferred enum dispatch - deserialize a “kind” field first, then re-deserialize the rest of the payload as the matching variant using the captured Value.
• Generic payload inspection - capture request/response bodies as a Value tree for logging, diffing, or transformation without committing to a schema.
• Format-agnostic passthrough - move data between two Serde-compatible formats (e.g. JSON to YAML) without defining an intermediate struct.

Under The Hood

Architecture serde-value is organized into three small modules under a flat src/ tree: lib.rs defines the central Value enum — one variant per Serde primitive kind (booleans, every integer width, both float widths, chars, strings, unit, options, newtypes, sequences, maps, and raw bytes) — along with manually written Hash, PartialEq, Ord, and PartialOrd implementations that pattern-match every variant pair explicitly rather than deriving them, so Value can be used as a map key or sorted despite embedding floats. ser.rs implements Serde’s Serialize trait directly on Value and exposes a to_value free function that runs any Serialize type through a small custom Serializer to build a Value tree. de.rs mirrors that on the deserialization side: it implements Deserialize for Value itself and provides a ValueDeserializer wrapper that turns an already-built Value back into a full Serde Deserializer, so it can be fed into any type’s Deserialize impl. There is no dependency injection or layering to speak of — it’s a single self-contained conversion library, and changing the Value enum’s variant set would ripple through all three files’ match arms at once.

Tech Stack Written in Rust (2018 edition) with a minimal dependency footprint: serde (^1.0.0) for the Serialize/Deserialize traits it implements against, and ordered-float (^2.0.0) so f32/f64 variants can participate in Hash/Ord. serde_derive is a dev-dependency only, used to derive Serialize/Deserialize on test fixtures. There’s no build step beyond cargo build — no codegen, no macros of its own. CI is configured via a .travis.yml, a dated choice reflecting the crate’s age; there is no GitHub Actions workflow.

Code Quality Tests live inline in lib.rs behind #[cfg(test)] rather than in a separate tests/ directory — six #[test] functions cover round-tripping a nested Value tree, converting a struct to Value via to_value, deserializing enums (unit and tuple variants) from Value, using ValueDeserializer inside a custom Deserialize impl for tag-based dispatch, and newtype-struct unwrapping. Error handling is explicit and typed: SerializerError and DeserializerError both implement std::error::Error plus Serde’s ser::Error/de::Error traits, so failures surface as normal Results rather than panics. There’s no linter or formatter configuration checked in, and the CI setup (Travis) is no longer actively maintained, which matches the repo’s inactive activity status.

API Design The public surface is deliberately small: to_value() to capture any Serialize value, Value::deserialize_into::<T>() to convert it back into a concrete type, and ValueDeserializer::new() for the rarer case of plugging a Value into someone else’s Deserialize impl. This mirrors the shape developers already know from serde_json::Value, so there’s very little to learn beyond “call to_value, later call deserialize_into.” Documentation exists as crate-level rustdoc on docs.rs but there’s no dedicated examples directory or guide beyond the README and the test suite, so newcomers have to read the tests to see the deferred-dispatch pattern in practice.