structio 0.8.0

High performance JSON and BEVE for Rust structs. No dependencies, no proc-macros, no intermediate representation.
Documentation
# structio documentation

Start with the [README](../README.md) for installation and a first example. These pages go deeper.

## Using the library

| | |
|---|---|
| [Schemas and types]schemas.md | Declaring a struct's schema as an object, as an array or as one field alone, renaming keys one at a time or by a case rule, accepting a second key for one, marking members the document has to carry, generics and borrowing, narrowing a declaration to one format or one direction, the supported type set, and writing the impls by hand. |
| [The derive]derive.md | `#[derive(Structio)]`, behind the `derive` feature: each attribute and the macro syntax it expands to, generics read off the type, what is refused and why, the later stages, and a table for anyone coming from serde. |
| [Enums]enums.md | Declaring a unit or tagged enum, the two wire forms and which of them reading accepts, renaming variants one at a time or by a case rule and accepting a second name for one, generics and borrowing, what is refused and with which error, how the policies meet a tag, and the string array a run of unit variants becomes in BEVE. |
| [BEVE]beve.md | What the binary format buys you, how it differs from JSON in practice, reaching one field without decoding the rest, turning a document you have no type for into JSON, complex numbers and matrices, writing arrays a reader can point at and borrowing one back, framing a body whose length has to be sent before it or that lands behind a header, reaching the typed-array path from a type this crate does not describe, and what is not implemented yet. |
| [Options]options.md | Indenting JSON, keeping arrays on one line, leaving null members out, refusing unknown keys, requiring every declared one, reading comments, laying out and minifying text that is already JSON, writing your own policy, and what the compile-time seam costs. |
| [Streaming]streaming.md | Reading documents that do not fit in memory, or have not fully arrived, and writing without assembling the output first. Both formats. |
| [Errors]errors.md | What errors carry, how to render them, and what each code means. |

## Understanding the library

| | |
|---|---|
| [Performance]performance.md | Benchmark results against Glaze, the methodology, and how to reproduce them. |
| [Correctness]correctness.md | What is tested and how, including the fuzzing, the exhaustive float sweep, and the Miri coverage. |
| [Design notes]design.md | How compile-time key hashing works, what the parser and writer do differently from the obvious implementation, and the trade-offs behind both. |
| [Schema declaration]schema-declaration.md | Why `object!` is a `macro_rules!` macro rather than a `#[derive]`, compared against the alternatives that were considered. |

## Reference

`cargo doc --open` builds the API reference. Every public item carries documentation, and the crate builds clean under `cargo doc`.