The Rust Standard Library

The Rust Standard Library provides the essential runtime functionality for building portable Rust software. It is linked to all Rust crates by default.

Intrinsic types and operations

The ptr and mem modules deal with unsafe pointers and memory manipulation. kinds defines the special built-in traits, and raw the runtime representation of Rust types. These are some of the lowest-level building blocks in Rust.

Math on primitive types and math traits

Although basic operations on primitive types are implemented directly by the compiler, the standard library additionally defines many common operations through traits defined in mod num.

Pervasive types

The option and result modules define optional and error-handling types, Option and Result. iter defines Rust's iterator protocol along with a wide variety of iterators. Cell and RefCell are for creating types that manage their own mutability.

Vectors, slices and strings

The common container type, Vec, a growable vector backed by an array, lives in the vec module. References to arrays, &[T], more commonly called "slices", are built-in types for which the slice module defines many methods.

&str, a UTF-8 string, is a built-in type, and the standard library defines methods for it on a variety of traits in the str module. Rust strings are immutable; use the String type defined in string for a mutable string builder.

For converting to strings use the format! macro, and for converting from strings use the FromStr trait.

Platform abstractions

Besides basic data types, the standard library is largely concerned with abstracting over differences in common platforms, most notably Windows and Unix derivatives. The os module provides a number of basic functions for interacting with the operating environment, including program arguments, environment variables, and directory navigation. The path module encapsulates the platform-specific rules for dealing with file paths.

std also includes modules for interoperating with the C language: c_str and c_vec.

Concurrency, I/O, and the runtime

The task module contains Rust's threading abstractions, while comm contains the channel types for message passing. sync contains further, primitive, shared memory types, including atomics.

Common types of I/O, including files, TCP, UDP, pipes, Unix domain sockets, timers, and process spawning, are defined in the io module.

Rust's I/O and concurrency depends on a small runtime interface that lives, along with its support code, in mod rt. While a notable part of the standard library's architecture, this module is not intended for public use.

The Rust prelude and macros

Finally, the prelude defines a common set of traits, types, and functions that are made available to all code by default. macros contains all the standard macros, such as assert!, fail!, println!, and format!, also available to all Rust code.

Modules

any

Traits for dynamic typing of any 'static type (through runtime reflection)

ascii

Operations on ASCII strings and characters

bitflags

The bitflags! macro generates a struct that holds a set of C-style bitmask flags. It is useful for creating typesafe wrappers for C APIs.

bool

The boolean type

boxed

A unique pointer type.

c_str

C-string manipulation and management

c_vec

Library to interface with chunks of memory allocated in C.

cell

Shareable mutable containers.

char

Character manipulation (char type, Unicode Scalar Value)

clone

The Clone trait for types that cannot be 'implicitly copied'

cmp

Defines the PartialOrd and PartialEq comparison traits.

collections

Collection types.

comm

Communication primitives for concurrent tasks

default

The Default trait for types which may have meaningful default values

dynamic_lib

Dynamic library facilities.

f32

Operations and constants for 32-bits floats (f32 type)

f64

Operations and constants for 64-bits floats (f64 type)

finally

The Finally trait provides a method, finally on stack closures that emulates Java-style try/finally blocks.

fmt

Utilities for formatting and printing strings

from_str

The FromStr trait for types that can be created from strings

gc

Task-local garbage-collected boxes

hash

Generic hashing support.

i16

Operations and constants for signed 16-bits integers (i16 type)

i32

Operations and constants for signed 32-bits integers (i32 type)

i64

Operations and constants for signed 64-bits integers (i64 type)

i8

Operations and constants for signed 8-bits integers (i8 type)

int

Operations and constants for architecture-sized signed integers (int type)

intrinsics

rustc compiler intrinsics.

io

I/O, including files, networking, timers, and processes

iter

Composable external iterators

kinds

Primitive traits representing basic 'kinds' of types

local_data

Task local data management

macros

Standard library macros

mem

Basic functions for dealing with memory

num

Numeric traits and functions for generic mathematics

ops

Overloadable operators

option

Optional values

os

Higher-level interfaces to libc::* functions and operating system services.

owned

A unique pointer type.

path

Cross-platform path support

prelude

The Rust prelude

ptr

Operations on unsafe pointers, *const T, and *mut T.

rand

Utilities for random number generation

raw

Contains struct definitions for the layout of compiler built-in types.

rc

Task-local reference-counted boxes (the Rc type).

result

Error handling with the Result type

rt

Runtime services, including the task scheduler and I/O dispatcher

simd

SIMD vectors.

slice

Utilities for slice manipulation

str

Unicode string manipulation (str type)

string

An owned, growable string that enforces that its contents are valid UTF-8.

sync

Useful synchronization primitives

task

Task creation

time

Temporal quantification.

to_string

The ToString trait for converting to strings

tuple

Operations on tuples

ty

Deprecated module in favor of std::cell

u16

Operations and constants for unsigned 16-bits integers (u16 type)

u32

Operations and constants for unsigned 32-bits integers (u32 type)

u64

Operations and constants for unsigned 64-bits integer (u64 type)

u8

Operations and constants for unsigned 8-bits integers (u8 type)

uint

Operations and constants for architecture-sized unsigned integers (uint type)

unit

The () type, sometimes called "unit" or "nil".

vec

An owned, growable vector.

Macros

assert!

Ensure that a boolean expression is true at runtime.

assert_eq!

Asserts that two expressions are equal to each other, testing equality in both directions.

bitflags!
bytes!

Concatenate literals into a static byte slice.

cfg!

Boolean evaluation of configuration flags.

col!

A macro which expands to the column number on which it was invoked.

concat!

Concatenates literals into a static string slice.

concat_idents!

Concatenate identifiers into one identifier.

debug_assert!

Ensure that a boolean expression is true at runtime.

debug_assert_eq!

Asserts that two expressions are equal to each other, testing equality in both directions.

env!

Inspect an environment variable at compile time.

fail!

The entry point for failure of rust tasks.

file!

A macro which expands to the file name from which it was invoked.

format!

Use the syntax described in std::fmt to create a value of type String. See std::fmt for more information.

format_args!

The core macro for formatted string creation & output.

include_bin!

Includes a file as a byte slice.

include_str!

Includes a utf8-encoded file as a string.

line!

A macro which expands to the line number on which it was invoked.

local_data_key!

Declare a task-local key with a specific type.

module_path!

Expands to a string that represents the current module path.

option_env!

Optionally inspect an environment variable at compile time.

print!

Equivalent to the println! macro except that a newline is not printed at the end of the message.

println!

Macro for printing to a task's stdout handle.

select!

A macro to select an event from a number of receivers.

stringify!

A macro which stringifies its argument.

try!

Helper macro for unwrapping Result values while returning early with an error if the value of the expression is Err. For more information, see std::io.

unimplemented!

A standardised placeholder for marking unfinished code. It fails with the message "not yet implemented" when executed.

unreachable!

A utility macro for indicating unreachable code. It will fail if executed. This is occasionally useful to put after loops that never terminate normally, but instead directly return from a function.

vec!

Create a std::vec::Vec containing the arguments.

write!

Use the format! syntax to write data into a buffer of type &mut Writer. See std::fmt for more information.

writeln!

Equivalent to the write! macro, except that a newline is appended after the message is written.