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, `T` or `mut T` should be used as appropriate.

Simple	`&'r T` Immutable borrowed reference	`&'r mut T` Mutable borrowed reference	`Box<T>` Owned pointer	`T` 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	`T` Primitive type, struct, enum and so on	`Trait+K` Unsized trait type Impossible today, the trait should be wrapped inside a box.
Vector	`&'r [T]` Immutable borrowed vector slice	`&'r mut [T]` Mutable borrowed vector slice	`Vec<T>` Owned vector	`[T, ..n]` Fixed-size vector	`[T]` Unsized vector type Impossible today, the vector should know its size at compile time or be wrapped inside a box.
String	`&'r str` Immutable borrowed string slice	`&'r mut str` Mutable borrowed string slice Impossible today, there are few operations available to the fixed-size mutable slice.	`String` Owned string	Fixed sized storage is impractical for the variable length UTF-8 encoding.	`str` Unsized string type Impossible today, the string should be wrapped inside a box.

Call-many	`\|&: T…\|:K -> U` `≡ FnShare<(T…), U>+K` Closure with immutable environment Impossible today, closures always assume a mutable environment.	`\|T…\|:K -> U` `≡ Fn<(T…), U>+K` `\|T…\|:'r:+K -> U` Closure with mutable environment	`FnShare<(T…), U>+K` `Fn<(T…), U>+K` Closure with owned environment Impossible today, closures cannot be sent.	`extern "ABI" fn(T…) -> U` Bare function type
Call-once	Procedures should be able to be consumed.	Procedures should be able to be consumed.	`\|: T…\|:K -> U` `≡ FnOnce<(T…), U>+K` `proc(T…):K -> U` Procedure with owned environment	`extern "ABI" fn(T…) -> U` Bare function type

	Supported as of 0.11
	Provided by the standard library
	Proposed
	Impossible

'r
Lifetime

K
Trait bounds

T…
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:

Guide

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.

Colored backgrounds (sorry the accessibility!) indicate the current availability. Black background means the type is plain absurd and prohibited. Striped background means the type is supported via the standard library. Gray background means the type makes some sense but it is not yet in the language. Fortunately we have two or three proposals that cover all the missing types now:

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.