Crate alloc1.36.0[][src]

Expand description

You are viewing the documentation of the Rust core allocation and collections library as a part of the Fortanix Rust EDP. There are no changes compared to the normal the core allocation and collections library.

The Rust core allocation and collections library

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 std crate. Crates that use the #![no_std] attribute however will typically not depend on std, so they’d use this crate instead.

Boxed values

The Box type is a smart pointer type. There can only be one owner of a Box, and the owner can decide to mutate the contents, which live on the heap.

This type can be sent among threads efficiently as the size of a Box value 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.

Reference counted pointers

The Rc type is a non-threadsafe reference-counted pointer type intended for sharing memory within a thread. An Rc pointer wraps a type, T, and only allows access to &T, a shared reference.

This type is useful when inherited mutability (such as using Box) is too constraining for an application, and is often paired with the Cell or RefCell types in order to allow mutation.

Atomically reference counted pointers

The Arc type is the threadsafe equivalent of the Rc type. It provides all the same functionality of Rc, except it requires that the contained type T is shareable. Additionally, Arc<T> is itself sendable while 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.

Heap interfaces

The alloc module defines the low-level interface to the default global allocator. It is not compatible with the libc allocator API.



The alloc Prelude

Memory allocation APIs

A module for working with borrowed data.

A pointer type for heap allocation.

Collection types.

Utilities for formatting and printing Strings.

Single-threaded reference-counting pointers. ‘Rc’ stands for ‘Reference Counted’.

A dynamically-sized view into a contiguous sequence, [T].

Unicode string slices.

A UTF-8–encoded, growable string.

Thread-safe reference-counting pointers.

Types and Traits for working with asynchronous tasks.

A contiguous growable array type with heap-allocated contents, written Vec<T>.


Creates a String using interpolation of runtime expressions.

Creates a Vec containing the arguments.