The Periodic Table of Rust Types

Immutable Pointer Mutable Pointer Owned Pointer Bare Unsized
Raw *const T
Immutable raw pointer
*mut T
Mutable raw pointer
Raw pointers do not have ownership, *const T or *mut T should be used as appropriate. See also Unique<T>.
Simple &'r T
Immutable borrowed reference
&'r mut T
Mutable borrowed reference
Owned pointer
Primitive type, struct, enum and so on
Trait &'r (Trait + K)
Immutable borrowed trait object
&'r mut (Trait + K)
Mutable borrowed trait object
Box<Trait + K>
Owned trait object
Trait + K
Unsized trait type
Array &'r [T]
Immutable borrowed slice
&'r mut [T]
Mutable borrowed slice
Owned array
Owned growable vector
[T; n]
Fixed-size array
Unsized array type
String &'r str
Immutable borrowed string slice
&'r mut str
Mutable borrowed string slice (not that useful)
Owned string (theoretical)
Owned growable string
Fixed sized storage is impractical for the variable length UTF-8 encoding.
Unsized string type
Callable Fn(T…) -> U + K
Closure with immutable environment
FnMut(T…) -> U + K
Closure with mutable environment
FnOnce(T…) -> U + K
Closure with owned environment
extern "ABI"
fn(T…) -> U

Bare function type
Supported as of 1.0.0-alpha
Provided by the standard library
Trait bounds
Function arguments
-> U
Function return
extern "ABI"
ABI definition

What is this?

This "periodic table" is a cheatsheet for various Rust types. Rust programming language has a versatile type system that avoids a certain class of memory error in the safe context, and consequently has somewhat many types at the first glance. This table organizes them into an orthogonal tabular form, making them easier to understand and reason.

This table does not indicate that Rust has a complex type system compared to other languages. Rust does have seemingly many types, but you only need to understand the meaning of each axis, or even just each column. There are some non-trivial but reasonable interactions between rows and columns though, therefore this table strives to illustrate that.

The periodic table was made by Kang Seonghoon as a thought experiment, and then... it have got redditted unexpectedly :p Henceforth I've made the URL permanent and added some descriptions. Some post-reddit changes include:

Discussion: /r/rust, /r/programming, Hacker News


Columns indicate the ownership. There are two big groups from left to right: indirect (i.e. pointers) and direct. Particularly indirect types can be used in place of other indirect types in many cases: &mut self methods can be used for Box<T> (when the box itself is mutable), and &self methods can be used for &mut T.

Rows indicate the different kind of types. There are three big groups from top to bottom: unsafe dereference, safe dereference and callable.

The owned column is special that every type is a library type; Box<T> is a representative smart pointer which is also most used, and Vec<T> and String are also representative growable types. Please note that there are several other types specialized to specific tasks (for example, Rc<T>).

Names for each cell are mostly from the Rusticon, but with necessary changes to make them consistent.

There are some optional syntactic parts possible in types. Many of them are turned off by default since they are normally verbose, but you can turn them on if you want.

Copyright © 2014–2015, Kang Seonghoon. This work is licensed under a Creative Commons Attribution 4.0 International License.

a part of