This library provides smart pointers and collections for managing heap-allocated values.
This library, like libcore, normally doesn’t need to be used directly
since its contents are re-exported in the
Crates that use the
#![no_std] attribute however will typically
not depend on
std, so they’d use this crate instead.
This type can be sent among threads efficiently as the size of a
is the same as that of a pointer. Tree-like data structures are often built
with boxes because each node often has only one owner, the parent.
Arc type is the threadsafe equivalent of the
Rc type. It
provides all the same functionality of
Rc, except it requires that the
T is shareable. Additionally,
Arc<T> is itself
Rc<T> is not.
This type allows for shared access to the contained data, and is often paired with synchronization primitives such as mutexes to allow mutation of shared resources.
Implementations of the most common general purpose data structures are defined in this library. They are re-exported through the standard collections library.
alloc module defines the low-level interface to the
default global allocator. It is not compatible with the libc allocator API.
The alloc Prelude
Types and Traits for working with asynchronous tasks.
Memory allocation APIs
A module for working with borrowed data.
A pointer type for heap allocation.
Utilities for formatting and printing
Single-threaded reference-counting pointers. 'Rc' stands for 'Reference Counted'.
A dynamically-sized view into a contiguous sequence,
Unicode string slices.
A UTF-8–encoded, growable string.
Thread-safe reference-counting pointers.
A contiguous growable array type with heap-allocated contents, written