Crates

One error type for applications: anyhow::Error holds any error, keeps the whole chain of causes, and lets ? work everywhere without writing a single From impl.

Base64 encoding and decoding, with the alphabet and padding rules made explicit. Pick an engine — standard, URL-safe, padded or not — and call encode and decode on it.

Turns a set of named bits into a real type. The bitflags! macro generates a struct with typed set operations, so a permissions mask stops being a bare u32 that anything can be assigned to.

Compiles C, C++ and assembly from a build script and links the result into your crate. The standard way a Rust crate wraps existing native code — and the reason that crate needs a C compiler to build.

The traits every RustCrypto hash implements. Write code once against Digest and it works with SHA-2, BLAKE2, SHA-3 or MD5 — and swapping the algorithm becomes a type parameter.

The SwissTable hash map that std::collections::HashMap is built from, available as a crate — for no_std code, custom allocators, the low-level HashTable, and lookups that don't allocate a key.

Case conversion between the shapes identifiers take: snake_case, camelCase, UpperCamelCase, kebab-case and the shouty variants — with one consistent rule for where a word begins.

A hash map that remembers insertion order and can be indexed by position. Hash lookup like HashMap, deterministic iteration like a Vec, and sorting without changing the type.

Extra iterator adaptors, as one extension trait: grouping, chunking, deduplication, combinations, and the Result-aware adaptors that let a fallible pipeline stay a pipeline.

Raw declarations of the platform's C library — types, constants, structs and functions, exactly as C sees them. The bottom layer under every crate that talks to the operating system, and unsafe all the way down.

The logging facade the ecosystem agrees on. Libraries call info! and warn! against it; the application chooses one implementation, and every library's output goes there.

Values initialised once, on first use: a cell you can fill later and a lazy static that runs its initialiser at first access. Most of it is now in std — this is the version for older toolchains, no_std, and the parts std still lacks.

A TokenStream that works outside a procedural macro. Mirrors the compiler's proc_macro API so macro code can be unit tested, called from ordinary functions, and reused by build scripts.

Quasi-quoting for procedural macros: write the Rust you want to generate as Rust, and interpolate values into it with #name. The output half of every macro, opposite syn.

Random number generation: a thread-local generator that needs no setup, seedable generators for reproducible runs, and the distributions and sequence operations — shuffle, choose, weighted pick — built on top.

The serialization framework the whole ecosystem shares. Derive Serialize and Deserialize once, and your type reads and writes JSON, TOML, YAML, MessagePack and the rest without knowing about any of them.

JSON for Rust: parse into your own types with from_str, write them back with to_string, or work with untyped Value when the shape isn't known ahead of time.

A Vec that keeps its first few elements inline instead of on the heap, spilling only when it outgrows them. A targeted allocation optimisation for collections that are usually small.

Parses a stream of Rust tokens into a syntax tree. The parsing half of every procedural macro — DeriveInput for derives, the Parse trait for custom syntax, and spanned errors that point at the user's code.

A derive for std::error::Error. Write the enum, put the message on each variant, and get Display, source() and the From conversions that make ? work — without the boilerplate, and without the macro appearing in your public API.