Crate std[src]
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, UPD, 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 |
| ascii | Operations on ASCII strings and characters |
| bitflags | The |
| bool | The boolean 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 ( |
| clone | The |
| cmp | Defines the |
| collections | Collection types. |
| comm | Communication primitives for concurrent tasks |
| default | The |
| dynamic_lib | Dynamic library facilities. |
| f32 | Operations and constants for 32-bits floats ( |
| f64 | Operations and constants for 64-bits floats ( |
| finally | The Finally trait provides a method, |
| fmt | Utilities for formatting and printing strings |
| from_str | The |
| gc | Task-local garbage-collected boxes |
| hash | Generic hashing support. |
| i16 | Operations and constants for signed 16-bits integers ( |
| i32 | Operations and constants for signed 32-bits integers ( |
| i64 | Operations and constants for signed 64-bits integers ( |
| i8 | Operations and constants for signed 8-bits integers ( |
| int | Operations and constants for architecture-sized signed integers ( |
| 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, |
| rand | Utilities for random number generation |
| raw | Contains struct definitions for the layout of compiler built-in types. |
| rc | Task-local reference-counted boxes ( |
| result | Error handling with the |
| rt | Runtime services, including the task scheduler and I/O dispatcher |
| simd | SIMD vectors. |
| slice | Utilities for vector manipulation |
| str | Unicode string manipulation ( |
| string | An owned, growable string that enforces that its contents are valid UTF-8. |
| sync | Useful synchronization primitives |
| task | Task creation |
| to_str | The |
| tuple | Operations on tuples |
| ty | Types dealing with unsafe actions. |
| u16 | Operations and constants for unsigned 16-bits integers ( |
| u32 | Operations and constants for unsigned 32-bits integers ( |
| u64 | Operations and constants for unsigned 64-bits integer ( |
| u8 | Operations and constants for unsigned 8-bits integers ( |
| uint | Operations and constants for architecture-sized unsigned integers ( |
| unstable | |
| vec | An owned, growable vector. |