Standard Library

The Standard Library provides essential functionality for Rust programs and includes modules for memory management, concurrency, collections, and more. The Standard Library is automatically included in every Rust project.

We listed below the (stable) modules of the Standard Library, highlighted the most important modules, and listed key types. Consult the complete documentation for the Standard Library↗ as well.

Modules	Description	See Also
`std::alloc`↗	Memory allocation APIs. For advanced users.	Memory Management
`std::any`↗	Utilities for dynamic typing or type reflection. Home of `Any`↗. Use for plugins, extensibility, scripting. Advanced.	Development Tools: Cargo Plugins Scripting
`std::arch`↗	SIMD and vendor intrinsics module. Advanced topic.	`std::simd`↗ module
`std::array`↗	Utilities for the array primitive type `[T; N]`.	Data Structures, Vectors, Slices
`std::ascii`↗	Operations on ASCII strings and characters. You may use `escape_default`↗	Encoding
`std::backtrace`↗	Support for capturing a stack backtrace of an OS thread.	Error Handling
`std::borrow`↗	A module for working with borrowed data. Home of `Borrow`↗ and `BorrowMut`↗.	Borrow, Ownership and Borrowing
`std::boxed`↗	The `Box<T>`↗ type for heap allocation.	Box
`std::cell`↗	Shareable mutable containers. Home of `RefCell<T>`↗.	Interior Mutability
`std::char`↗	Utilities for the char↗ primitive type.
`std::clone`↗	The `Clone`↗ trait for types that cannot be implicitly copied.	`ToOwned`↗, Cow
`std::cmp`↗	Utilities for comparing and ordering values. Home of `PartialEq`↗, `Eq`↗, `PartialOrd`↗, `Ord`↗.	Equality and Ordering, Algorithms, Sorting
`std::collections`↗	Collection types. Home of `HashMap`↗, `HashSet`↗ and others.	HashMap, Data Structures
`std::convert`↗	Traits for conversions between types: `AsRef`↗, `From`↗ and others.	AsRef
`std::default`↗	The `Default`↗ trait for types with a default value.	Conversion Traits,
`std::env`↗	Inspection and manipulation of the process's environment.	Environment Variables
`std::error`↗	`Error`↗ Interfaces.	Error Handling
`std::f32`↗	Constants for the `f32` single-precision floating point type.	Data Types
`std::f64`↗	Constants for the `f64` double-precision floating point type.	Data Types
`std::ffi`↗	Utilities related to FFI bindings. Home of `OsString`↗ and `CString`↗.	Other Strings
`std::fmt`↗	Utilities for formatting and printing Strings. Home of the `Write`↗ trait.	Strings, `format!`↗ macro
`std::fs`↗	Filesystem manipulation operations. Home of `File`↗ and many useful functions.	Filesystem, Directories
`std::future`↗	Asynchronous basic functionality. Home of the `Future`↗ trait.	Async
`std::hash`↗	Generic hashing support. Home of the `Hash`↗ trait.	Cryptography, Data Structures
`std::hint`↗	Hints to compiler that affects how code should be emitted or optimized. Advanced.	Benchmarking
`std::io`↗	Traits, helpers, and type definitions for core I/O functionality. Home of the `Read`↗ and `Write`↗ traits and useful functions.	Read & Write from Files
`std::iter`↗	Composable external iteration. Home of the `Iterator`↗ and `IntoIterator`↗ traits.	Iterators
`std::marker`↗	Primitive traits and types representing basic properties of types. Home of `Send`↗, `Sync`↗, `Sized`↗, `Copy`↗, and `PhantomData`↗.	Send & Sync, Ownership & Borrowing, Derive
`std::mem`↗	Basic functions for dealing with memory, such as `drop`↗.	Memory Management
`std::net`↗	Networking primitives for TCP/UDP communication. Home of `IpAddr`↗ and `TcpListener`↗.	Network Programming
`std::num`↗	Additional functionality for numerics. Home of `NonZero`↗, `Saturating`↗, and `Wrapping`↗.	Data Types, Mathematics
`std::ops`↗	Overloadable operators, e.g., `Add`↗, `Mul`↗ and `Index`↗. Also home of `Fn`↗ and related traits; `Deref`↗ and `Drop`↗.	Ops, Drop, Closures, Memory Management
`std::option`↗	Optional values via `Option`↗.	Option
`std::os`↗	OS-specific functionality.	OS
`std::panic`↗	Panic support in the standard library.	Error Handling
`std::path`↗	Cross-platform path manipulation with `PathBuf`↗ and `Path`↗	Filesystem
`std::pin`↗	Types that pin data to a location in memory, via `Pin`↗.	Pin, Rust-specific Patterns
`std::prelude`↗	The prelude that Rust automatically imports into every Rust program.	Code Organization
`std::primitive`↗	This module reexports the primitive types to allow usage that is not possibly shadowed by other declared types.	Data Types
`std::process`↗	A module for working with processes. Home of `Command`↗ and `exit()`↗.	External Commands
`std::ptr`↗	Manually manage memory through raw pointers, e.g. `NotNull`↗ and many unsafe functions. Advanced topic.	Ownership & Borrowing
`std::rc`↗	Single-threaded reference-counting pointers. 'Rc' stands for "Reference Counted". See `Rc`↗.	Reference Counting
`std::result`↗	Error handling with the `Result`↗ type.	Result
`std::slice`↗	Utilities for the slice↗ primitive type.	Slices
`std::str`↗	Utilities for the `str`↗ primitive type.	Slices, String
`std::string`↗	A UTF-8–encoded, growable `String`↗.	String
`std::sync`↗	Useful synchronization primitives: `Arc`↗, `Mutex`↗, `LazyLock`↗.	Concurrency, Smart Pointers, Sync
`std::task`↗	Types and Traits for working with asynchronous tasks. For advanced users.	Asynchronous
`std::thread`↗	Native threads with `Thread`↗.	Explicit Thread
`std::time`↗	Temporal quantification with `Duration`↗ and `Instant`↗.	Date & Time
`std::vec`↗	A contiguous growable array type with heap-allocated contents, written `Vec<T>`↗.	Vectors

The following covers portions of the Rust Standard Library that are not otherwise covered by another chapter: core types like Option↗, Result↗; smart pointers; and traits for conversions.

Optional Values: `Option`

Recipe	Crates
Store Optional Values in `Option`
Use Adapters when Working with References
Extract the Value Contained in an `Option` with `unwrap*` and `expect`
Transform Values Contained Within an `Option`
Use `Option` with `match`, `if let`, or `while let`
Work with the Contents of an `Option`
Implement the "Early Return" Pattern with the `?` Operator

Recoverable Error Handling: `Result`

Recipe	Crates
Handle Recoverable Errors with `Result`
Retrieve or Transform Values in `Result`
Get Reference to Values Inside a `Result`
Choose between `Result` and `Option`

Default Values: `Default`

Recipe	Crates
Define Default Values for a Struct with `Default`

Value Comparison: Equality and Ordering

Recipe	Crates
Test for Equality with `PartialEq` and `Eq`
Compare and Sort Values with `PartialOrd` and `Ord`

Smart Pointers

Recipe	Crates
Implement a Smart Pointer with `Deref`
Smart Pointer Comparison
Multiple Ownership with Reference Counting
Interior Mutability
Lazy Initialization
Synchronization Primitives

Heap Storage with `Box`

Recipe	Crates
Store Data on the Heap with `Box`
Decide When to Use `Box`
Use `Box` to Store Dynamically Sized Types
Implement Recursive Data Structures with `Box`
Use `Box` as a Smart Pointer to Owned Trait Objects

Reference Counting: `Rc`, `Arc`

Recipe	Crates
Share Ownership of a Value with `Rc`
Share Ownership of a Value with Interior Mutability via `Rc` and `RefCell`
Share Ownership of a Value with `Rc`

Interior Mutability: `RefCell`, `Cell`, `OnceCell`

Recipe	Crates
Use `Cell`
Use `RefCell`
Use `OnceCell`

Clone-on-Write: `Cow`

Recipe	Crates
Accept Either a Owned or Borrowed Value as the Input of a Function
Convert a `Cow` to a Borrowed or Owned Type
Efficiently Construct a `Cow` with `into`
Modify a `Cow` In-place
Return a `Cow` from a Function
Use `Arc`, `Rc`, `Box` as `Cow` Alternatives
Clone Data Lazily with `Cow`

Memory Address Pinning: `Pin`

Recipe	Crates
Give Data a Stable Memory Address with `Pin`

Resource Cleanup: `Drop`

Recipe	Crates
Release External Resources by Implementing the `Drop` Trait

Conversion Traits: `From`, `Into`, `TryFrom`, `TryInto`

Recipe	Crates
Choose the Right Trait for a Conversion
Convert between Types with `From`

Reference-to-reference Conversion: `AsRef`

Recipe	Crates
Accept Arguments of Multiple Types with `AsRef`
Use `as_ref` to Get a Reference to the Contained Value of a Smart Pointer
Choose between `AsRef`, `Deref`, and `Borrow`

Borrowed Types: `Borrow`

Recipe	Crates
Use the `Borrow` Trait to Work with Borrowed Types Synonymous with Owned Types
Differences between `Borrow`, `Deref`, and `AsRef` in Generic Code
Implement `Borrow` for a Custom Type

Automatic Trait Derivation: `derive`

Recipe	Crates
Derive Common Traits Automatically
Derive Additional Traits with `derive_more`

Operators

Recipe	Crates
Add Function-like Behavior to a Custom Type
Overload Operators like `+`, `-`, `[]`

Dynamic Typing: `Any`

Recipe	Crates
Determine the Type of an Object at Runtime and Downcast with the `Any` Trait
Compile-time Reflection

The Rust How-to Book