alloc - Rust
Description: API documentation for the Rust `alloc` crate.
Keywords: rust, rustlang, rust-lang, alloc

# Crate alloc [−] [src]

🔬 This is a nightly-only experimental API. (`alloc` #27783)

this library is unlikely to be stabilized in its current form or name

# The Rust core allocation and collections library

This library provides smart pointers and collections for managing heap-allocated values.

This library, like libcore, is not intended for general usage, but rather as a building block of other libraries. The types and interfaces in this library are reexported through the standard library, and should not be used through this library.

## 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.

## Collections

Implementations of the most common general purpose data structures are defined in this library. They are reexported through the standard collections library.

## Heap interfaces

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

## Reexports

`pub use binary_heap::BinaryHeap;`
`pub use btree_map::BTreeMap;`
`pub use btree_set::BTreeSet;`
`pub use linked_list::LinkedList;`
`pub use vec_deque::VecDeque;`
`pub use string::String;`
`pub use vec::Vec;`

## Modules

arc | Thread-safe reference-counting pointers.
binary_heap | A priority queue implemented with a binary heap.
borrow | A module for working with borrowed data.
boxed | A pointer type for heap allocation.
btree_map | A map based on a B-Tree.
btree_set | A set based on a B-Tree.
fmt | Utilities for formatting and printing `String`s
linked_list | A doubly-linked list with owned nodes.
rc | Single-threaded reference-counting pointers. 'Rc' stands for 'Reference Counted'.
slice | A dynamically-sized view into a contiguous sequence, `[T]`.
str | Unicode string slices.
string | A UTF-8 encoded, growable string.
vec | A contiguous growable array type with heap-allocated contents, written `Vec<T>`.
vec_deque | A double-ended queue implemented with a growable ring buffer.
allocator | [ Experimental ]
heap | [ Experimental ]
range | [ Experimental ] Range syntax.
raw_vec | [ Experimental ]

## Macros

format | Creates a `String` using interpolation of runtime expressions.
vec | Creates a `Vec` containing the arguments.

## Enums

Bound | An endpoint of a range of keys.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)