21/08/2020 Rust Language Cheat Sheet

Rust Language Cheat Sheet

20.08.2020

Contains clickable links to The Book BK, Rust by Example EX, Std Docs STD, Nomicon NOM, Reference REF. Other symbols used:
largely deprecated 🗑, has a minimum edition '18, is work in progress 🚧, or bad 🛑.

Fira Code Ligatures ( ..=, => ) Night Mode 💡

Data Structures
Data types and memory locations de ned via keywords.

Example Explanation
struct S {} De ne a struct BK EX STD REF with named elds.

     struct S { x: T } De ne struct with named eld x of type T .

     struct S (T); De ne "tupled" struct with numbered eld .0 of type T .

     struct S; De ne zero sized NOM unit struct. Occupies no space, optimized away.

enum E {} De ne an enum BK EX REF , c. algebraic data types, tagged unions.

     enum E { A, B (), C {} } De ne variants of enum; can be unit- A , tuple- B () and struct-like C{} .

     enum E { A = 1 } If variants are only unit-like, allow discriminant values, e.g., for FFI.

union U {} Unsafe C-like union REF for FFI compatibility.

static X: T = T(); Global variable BK EX REF with 'static lifetime, single memory location.

const X: T = T(); De nes constant BK EX REF. Copied into a temporary when used.

let x: T; Allocate T bytes on stack1 bound as x . Assignable once, not mutable.

let mut x: T; Like let , but allow for mutability BK EX and mutable borrow.2

     x = y; Moves y to x , invalidating y if T is not Copy , STD and copying y otherwise.

1
Bound variables BK EX REF live on stack for synchronous code. In async {} code they become part async's state machine, may reside on heap.
2
Technically mutable and immutable are misnomer. Immutable binding or shared reference may still contain Cell STD, giving interior mutability.

 
Creating and accessing data structures; and some more sigilic types.

Example Explanation
S { x: y } Create struct S {} or use 'ed enum E::S {} with eld x set to y .

S { x } Same, but use local variable x for eld x .

S { ..s } Fill remaining elds from s , esp. useful with Default.

S { 0: x } Like S (x) below, but set eld .0 with struct syntax.

S (x) Create struct S (T) or use 'ed enum E::S () with eld .0 set to x .

S If S is unit struct S; or use 'ed enum E::S create value of S .

E::C { x: y } Create enum variant C . Other methods above also work.

() Empty tuple, both literal and type, aka unit. STD

(x) Parenthesized expression.

(x,) Single-element tuple expression. EX STD REF

(S,) Single-element tuple type.

https://cheats.rs/#printing-pdf 1/16
21/08/2020 Rust Language Cheat Sheet

Example Explanation
[S] Array type of unspeci ed length, i.e., slice. EX STD REF Can't live on stack. *

[S; n] Array type EX STD of xed length n holding elements of type S .

[x; n] Array instance with n copies of x . REF

[x, y] Array instance with given elements x and y .

x[0] Collection indexing. Overloadable Index, IndexMut

x[..] Collection slice-like indexing via RangeFull, c. slices.

x[a..] Collection slice-like indexing via RangeFrom.

x[..b] Collection slice-like indexing RangeTo.

x[a..b] Collection slice-like indexing via Range.

a..b Right-exclusive range REF creation, also seen as ..b .

a..=b Inclusive range creation, also seen as ..=b .

s.x Named eld access, REF might try to Deref if x not part of type S .

s.0 Numbered eld access, used for tuple types S (T) .

*
For now, see tracking issue and corresponding RFC 1909.

References & Pointers

Granting access to un-owned memory. Also see section on Generics & Constraints.

Example Explanation
&S Shared reference BK STD NOM REF
(space for holding any &s ).

     &[S] Special slice reference that contains ( address , length ).

     &str Special string reference that contains ( address , length ).

     &mut S Exclusive reference to allow mutability (also &mut [S] , &mut dyn S , ...)

     &dyn T Special trait object BK reference that contains ( address , vtable ).

*const S Immutable raw pointer type BK STD REF w/o memory safety.

*mut S Mutable raw pointer type w/o memory safety.

&s Shared borrow BK EX STD (e.g., address, len, vtable, ... of this s , like 0x1234 ).

&mut s Exclusive borrow that allows mutability. EX

ref s Bind by reference. EX 🗑

     let ref r = s; Equivalent to let r = &s .

     let S { ref mut x } = s; Mutable ref binding ( let x = &mut s.x ), shorthand destructuring ↓ version.

*r Dereference BK STD NOM a reference r to access what it points to.

     *r = s; If r is a mutable reference, move or copy s to target memory.

     s = *r; Make s a copy of whatever r references, if that is Copy .

     s = *my_box; Special case for Box that can also move out Box'ed content if it isn't Copy .

'a A lifetime parameter, BK EX NOM REF, duration of a ow in static analysis.

     &'a S Only accepts a s with an address that lives 'a or longer.

     &'a mut S Same, but allow content of address to be changed.

     struct S<'a> {} Signals S will contain address with lifetime 'a . Creator of S decides 'a .

     trait T<'a> {} Signals a S which impl T for S might contain address.

     fn f<'a>(t: &'a T) Same, for function. Caller decides 'a .

'static Special lifetime lasting the entire program execution.

Functions & Behavior

De ne units of code and their abstractions.

https://cheats.rs/#printing-pdf 2/16
21/08/2020 Rust Language Cheat Sheet

Example Explanation
trait T {} De ne a trait; BK EX REF common behavior others can implement.

trait T : R {} T is subtrait of supertrait REF R . Any S must impl R before it can impl T .

impl S {} Implementation REF of functionality for a type S , e.g., methods.

impl T for S {} Implement trait T for type S .

impl !T for S {} Disable an automatically derived auto trait NOM REF.

fn f() {} De nition of a function; BK EX REF or associated function if inside impl .

     fn f() -> S {} Same, returning a value of type S.

     fn f(&self) {} De ne a method, BK EX e.g., within an impl S {} .

const fn f() {} Constant fn usable at compile time, e.g., const X: u32 = f(Y) . '18

async fn f() {} Async REF '18 function transformation, makes f return an impl Future . STD

     async fn f() -> S {} Same, but make f return an impl Future<Output=S> .

     async { x } Used within a function, make { x } an impl Future<Output=X> .

fn() -> S Function pointers, BK STD REF, memory holding address of a callable.

Fn() -> S Callable Trait, BK STD (also FnMut , FnOnce ), implemented by closures, fn's ...

|| {} A closure BK EX REF that borrows its captures. REF

     |x| {} Closure with a bound parameter x .

     |x| x + x Closure without block expression; may only consist of single expression.

     move |x| x + y Closure taking ownership of its captures.

     return || true Closures sometimes look like logical ORs (here: return a closure).

unsafe {} If you enjoy debugging segfaults Friday night; unsafe code. BK EX NOM REF

Control Flow
Control execution within a function.

Example Explanation
while x {} Loop , run while expression x is true.
REF

loop {} Loop in nitely REF until break . Can yield value with break x .

for x in iter {} Syntactic sugar to loop over iterators. BK STD REF

if x {} else {} Conditional branch REF if expression is true.

'label: loop {} Loop label EX REF, useful for ow control in nested loops.

break Break expression REF to exit a loop.

     break x Same, but make x value of the loop expression (only in actual loop ).

     break 'label Exit not only this loop, but the enclosing one marked with 'label .

continue Continue expression REF to the next loop iteration of this loop.

continue 'label Same, but instead of enclosing loop marked with 'label .

x? If x is Err or None, return and propagate. BK EX STD REF

x.await Only works inside async . Yield ow until Future STD

or Stream x ready. REF '18

return x Early return from function. More idiomatic way is to end with expression.

f() Invoke callable f (e.g., a function, closure, function pointer, Fn , ...).

x.f() Call member function, requires f takes self , &self , ... as rst argument.

     X::f(x) Same as x.f() . Unless impl Copy for X {} , f can only be called once.

     X::f(&x) Same as x.f() .

     X::f(&mut x) Same as x.f() .

     S::f(&x) Same as x.f() if X derefs to S , i.e., x.f() nds methods of S .

     T::f(&x) Same as x.f() if X impl T , i.e., x.f() nds methods of T if in scope.

https://cheats.rs/#printing-pdf 3/16
21/08/2020 Rust Language Cheat Sheet

Example Explanation
X::f() Call associated function, e.g., X::new() .

     <X as T>::f() Call trait method T::f() implemented for X .

Organizing Code
Segment projects into smaller units and minimize dependencies.

Example Explanation
mod m {} De ne a module, BK EX REF get de nition from inside {} . ↓

mod m; De ne a module, get de nition from m.rs or m/mod.rs . ↓

a::b Namespace path EX REF to element b within a ( mod , enum , ...).

     ::b Search b relative to crate root. 🗑

     crate::b Search b relative to crate root. '18

     self::b Search b relative to current module.

     super::b Search b relative to parent module.

use a::b; Use EX REF b directly in this scope without requiring a anymore.

use a::{b, c}; Same, but bring b and c into scope.

use a::b as x; Bring b into scope but name x , like use std::error::Error as E .

use a::b as _; Bring b anonymously into scope, useful for traits with con icting names.

use a::*; Bring everything from a into scope.

pub use a::b; Bring a::b into scope and reexport from here.

pub T "Public if parent path is public" visibility BK for T .

     pub(crate) T Visible at most in current crate.

     pub(self) T Visible at most in current module.

     pub(super) T Visible at most in parent.

     pub(in a::b) T Visible at most in a::b .

extern crate a; Declare dependency on external crate BK EX REF 🗑 ; just use a::b in '18.

extern "C" {} Declare external dependencies and ABI (e.g., "C" ) from FFI. BK EX NOM REF

extern "C" fn f() {} De ne function to be exported with ABI (e.g., "C" ) to FFI.

Type Aliases and Casts

Short-hand names of types, and methods to convert one type to another.

Example Explanation
type T = S; Create a type alias , i.e., another name for S .
BK REF

Self Type alias for implementing type REF, e.g. fn new() -> Self .

self Method subject in fn f(self) {} , same as fn f(self: Self) {} .

     &self Same, but refers to self as borrowed, same as f(self: &Self)

     &mut self Same, but mutably borrowed, same as f(self: &mut Self)

     self: Box<Self> Arbitrary self type, add methods to smart pointers ( my_box.f_of_self() ).

S as T Disambiguate BK REF type S as trait T , e.g., <S as T>::f() .

S as R In use of symbol, import S as R , e.g., use a::S as R .

x as u32 Primitive cast EX REF, may truncate and be a bit surprising. NOM

Macros & Attributes

Code generation constructs expanded before the actual compilation happens.

https://cheats.rs/#printing-pdf 4/16
21/08/2020 Rust Language Cheat Sheet

Example Explanation
m!() Macro BK STD REF invocation, also m!{} , m![] (depending on macro).

#[attr] Outer attribute. EX REF, annotating the following item.

#![attr] Inner attribute, annotating the surrounding item.

 
Inside a declarative BK macro by example BK EX REF macro_rules! implementation these work:

Within Macros Explanation

$x:ty Macro capture, with the ty part being:

     $x:item An item, like a function, struct, module, etc.

     $x:block A block {} of statements or expressions, e.g., { let x = 5; }

     $x:stmt A statement, e.g., let x = 1 + 1; , String::new(); or vec![];

     $x:expr An expression, e.g., x , 1 + 1 , String::new() or vec![]

     $x:pat A pattern, e.g., Some(t) , (17, 'a') or _ .

     $x:ty A type, e.g., String , usize or Vec<u8> .

     $x:ident An identi er, for example in let x = 0; the identi er is x .

     $x:path A path (e.g. foo , ::std::mem::replace , transmute::<_, int> , …).

     $x:literal A literal (e.g. 3 , "foo" , b"bar" , etc.).

     $x:lifetime A lifetime (e.g. 'a , 'static , etc.).

     $x:meta A meta item; the things that go inside #[...] and #![...] attributes.

     $x:vis A visibility modi er; pub , pub(crate) , etc.

     $x:tt A single token tree, see here for more details.

$x Macro substitution, e.g., use the captured $x:ty from above.

$(x),* Macro repetition "zero or more times" in macros by example.

     $(x),? Same, but "zero or one time".

     $(x),+ Same, but "one or more times".

     $(x)<<+ In fact separators other than , are also accepted. Here: << .

$crate Special hygiene variable, crate where macros is de ned. ?

 

Pattern Matching
Constructs found in match or let expressions, or function parameters.

Example Explanation
match m {} Initiate pattern matching BK EX REF, then use match arms, c. next table.

let S(x) = get(); Notably, let also destructures EX similar to the table below.

     let S { x } = s; Only x will be bound to value s.x .

     let (_, b, _) = abc; Only b will be bound to value abc.1 .

     let (a, ..) = abc; Ignoring 'the rest' also works.

     let (.., a, b) = (1, 2); Speci c bindings take precedence over 'the rest', here a is 1 , b is 2 .

     let Some(x) = get(); Won't work 🛑 if pattern can be refuted REF, use if let instead.

if let Some(x) = get() {} Branch if pattern can be assigned (e.g., enum variant), syntactic sugar. *

fn f(S { x }: S) Function parameters also work like let , here x bound to s.x of f(s) .
*
Desugars to match get() { Some(x) => {}, _ => () } .

 
Pattern matching arms in match expressions. Left side of these arms can also be found in let expressions.

Match Arm Explanation

E::A => {} Match enum variant A , c. pattern matching. BK EX REF

https://cheats.rs/#printing-pdf 5/16
21/08/2020 Rust Language Cheat Sheet

Match Arm Explanation

E::B ( .. ) => {} Match enum tuple variant B , wildcard any index.

E::C { .. } => {} Match enum struct variant C , wildcard any eld.

S { x: 0, y: 1 } => {} Match struct with speci c values (only accepts s with s.x of 0 and s.y of 1 ).

S { x: a, y: b } => {} Match struct with any(!) values and bind s.x to a and s.y to b .

     S { x, y } => {} Same, but shorthand with s.x and s.y bound as x and y respectively.

S { .. } => {} Match struct with any values.

D => {} Match enum variant E::D if D in use .

D => {} Match anything, bind D ; possibly false friend 🛑 of E::D if D not in use .

_ => {} Proper wildcard that matches anything / "all the rest".

(a, 0) => {} Match tuple with any value for a and 0 for second.

[a, 0] => {} Slice pattern, REF 🔗 match array with any value for a and 0 for second.

     [1, ..] => {} Match array starting with 1 , any value for rest; subslice pattern. ?

     [2, .., 5] => {} Match array starting with 1 , ending with 5 .

     [2, x @ .., 5] => {} Same, but also bind x to slice representing middle (c. next entry).

x @ 1..=5 => {} Bind matched to x ; pattern binding, BK EX REF here x would be 1 , 2 , ... or 5 .

0 | 1 => {} Pattern alternatives (or-patterns).

     E::A | E::Z Same, but on enum variants.

     E::C {x} | E::D {x} Same, but bind x if all variants have it.

S { x } if x > 10 => {} Pattern match guards, BK EX REF condition must be true as well to match.

Generics & Constraints

Generics combine with many other constructs such as struct S<T> , fn f<T>() , ...

Example Explanation
S<T> A generic BK EX type with a type parameter ( T is placeholder name here).

S<T: R> Type short hand trait bound BK EX speci cation ( R must be actual trait).

     T: R, P: S Independent trait bounds (here one for T and one for P ).

     T: R, S Compile error, 🛑 you probably want compound bound R + S below.

     T: R + S Compound trait bound BK EX, T must ful ll R and S .

     T: R + 'a Same, but w. lifetime. T must ful ll R , if T has lifetimes, must outlive 'a .

     T: ?Sized Opt out of a pre-de ned trait bound, here Sized . ?

     T: 'a Type lifetime bound EX; if T has references, they must outlive 'a .

     T: 'static Same; does esp. not mean value t will 🛑 live 'static , only that it could.

     'b: 'a Lifetime 'b must live at least as long as (i.e., outlive) 'a bound.

S<T> where T: R Same as S<T: R> but more pleasant to read for longer bounds.

S<T = R> Default type parameter BK for associated type.

S<'_> Inferred anonymous lifetime; asks compiler to ' gure it out' if obvious.

S<_> Inferred anonymous type, e.g., as let x: Vec<_> = iter.collect()

S::<T> Turbo sh STD call site type disambiguation, e.g. f::<u32>() .

trait T<X> {} A trait generic over X . Can have multiple impl T for S (one per X ).

trait T { type X; } De nes associated type BK REF X . Only one impl T for S possible.

     type X = R; Set associated type within impl T for S { type X = R; } .

impl<T> S<T> {} Implement functionality for any T in S<T> .

impl S<T> {} Implement functionality for exactly S<T> (e.g., S<u32> ).

fn f() -> impl T Existential types BK, returns an unknown-to-caller S that impl T .

https://cheats.rs/#printing-pdf 6/16
21/08/2020 Rust Language Cheat Sheet

Example Explanation
fn f(x: &impl T) Trait bound,"impl traits" BK
, somewhat similar to fn f<S:T>(x: &S) .

fn f(x: &dyn T) Marker for dynamic dispatch BK REF, f will not be monomorphized.

fn f() where Self: R; In trait T {} , make f accessible only on types known to also impl R .

     fn f() where Self: R {} Esp. useful w. default methods (non d t. would need be impl'ed anyway).

for<'a> Higher-ranked trait bounds. NOM REF

     trait T: for<'a> R<'a> {} Any S that impl T would also have to ful ll R for any lifetime.

Strings & Chars

Rust has several ways to create textual values.

Example Explanation
"..." String literal, REF UTF-8, will interpret \n as line break 0xA , ...

r"..." Raw string literal. REF UTF-8, won't interpret \n , ...

r#"..."# Raw string literal, UTF-8, but can also contain " . Number of # can vary.

b"..." Byte string literal; REF constructs ASCII [u8] , not a string.

br"..." , br#"..."# Raw byte string literal, ASCII [u8] , combination of the above.

'🦀' Character literal, REF xed 4 byte unicode 'char'. STD

b'x' ASCII byte literal. REF

Comments
No comment.

Example Explanation
// Line comment, use these to document code ow or internals.

/// Outer line doc comment, BK EX REF use these on types.

//! Inner line doc comment, mostly used at start of le to document module.

/*...*/ Block comment.

/**...*/ Outer block doc comment.

/*!...*/ Inner block doc comment.

```rust ... ``` In doc comments, include a doc test (doc code running on cargo test ).

# In doc tests, hide line from documentation ( ``` # use x::hidden; ``` ).

Miscellaneous
These sigils did not t any other category but are good to know nonetheless.

Example Explanation
! Always empty never type. 🚧 BK EX STD REF

_ Unnamed variable binding, e.g., |x, _| {} .

     let _ = x; Unnamed assignment is no-op, does not 🛑 move out x or preserve scope!

_x Variable binding explicitly marked as unused.

1_234_567 Numeric separator for visual clarity.

1_u8 Type speci er for numeric literals EX REF (also i8 , u16 , ...).

0xBEEF , 0o777 , 0b1001 Hexadecimal ( 0x ), octal ( 0o ) and binary ( 0b ) integer literals.

r#foo A raw identi er BK EX for edition compatibility.

x; Statement REF terminator, c. expressions EX REF

https://cheats.rs/#printing-pdf 7/16
21/08/2020 Rust Language Cheat Sheet

Common Operators
Rust supports most operators you would expect ( + , * , % , = , == ...), including overloading. STD Since they behave no di erently in Rust
we do not list them here.

Behind the Scenes

Language Sugar
If something works that "shouldn't work now that you think about it", it might be due to one of these.

Name Description
Coercions NOM
'Weaken' types to match signature, e.g., &mut T to &T .

Deref NOM
Deref x: T until *x , **x , ... compatible with some target S .

Prelude STD Automatic import of basic types.

Reborrow Since x: &mut T can't be copied; move new &mut *x instead.

Lifetime Elision BK NOM REF

Automatically annotate f(x: &T) to f<'a>(x: &'a T) .

Method Resolution REF Deref or borrow x until x.f() works.

 

Editorial Comment 💬 — The features above will make your life easier, but might hinder your understanding. If you are new to
Rust, you should consider reading about them in more detail.

Standard Library

Common One-Liners
Snippets that are common, but still easy to forget. See Rust Cookbook 🔗 for more.

Intent Snippet
Parse a number "42".parse::<u32>()?

Create a new le OpenOptions::new().create(true).write(true).open(PATH)?

Fix inference in ' try ' closures iter.try_for_each(|x| { Ok::<(), Error>(()) })?;

Macro w. variable arguments macro_rules! var_args { ($($args:expr),*) => {{ }} }

     Using the arguments      $( f($args); )*

 

Traits
Traits de ne common behavior. If S implements trait T , you know S can behave as prescribed by T . Below is an overview of traits
that may be more tricky.

Thread Safety

Examples Send * !Send

Sync * Most types ... Mutex<T> , Arc<T> 1,2 MutexGuard<T> 1, RwLockReadGuard<T> 1

https://cheats.rs/#printing-pdf 8/16
21/08/2020 Rust Language Cheat Sheet

Examples Send *
!Send

!Sync Cell<T> 2, RefCell<T> 2 Rc<T> , Formatter , &dyn Trait

*
An instance t where T: Send can be moved to another thread, a T: Sync means &t can be moved to another thread.
1
If T is Sync .
2
If T is Send .

🐘 (Dynamically / Zero) Sized Types

Overview Sized in Bounds

A type T is Sized STD if at compile time it is known how many bytes it occupies, u8 and &[u8] are,
[u8] isn't.
Being Sized means impl Sized for T {} holds. Happens automatically and cannot be user
impl'ed.
Types not Sized are called dynamically sized types BK NOM REF (DSTs), sometimes unsized.
Types without data are called zero sized types NOM (ZSTs), do not occupy space.

🚥 Iterators

Using Iterators Implementing Iterators

Basics

Assume you have a collection c of type C :

c.into_iter() — Turns collection c into an Iterator STD i and consumes* c . Requires

IntoIterator STD for C to be implemented. Type of item depends on what C was. 'Standardized'
way to get Iterators.
c.iter() — Courtesy method some collections provide, returns borrowing Iterator, doesn't
consume c .
c.iter_mut() — Same, but mutably borrowing Iterator that allow collection to be changed.

The Iterator

Once you have an i :

i.next() — Returns Some(x) next element c provides, or None if we're done.

For Loops

for x in c {} — Syntactic sugar, calls c.into_iter() and loops i until None .

*
If it looks as if it doesn't consume c that's because type was Copy . For example, if you call (&c).into_iter() it will invoke
.into_iter() on &c (which will consume the reference and turn it into an Iterator), but c remains untouched.

String Conversions
If you want a string of type ...

https://cheats.rs/#printing-pdf 9/16
21/08/2020 Rust Language Cheat Sheet

String CString OsString PathBuf Vec<u8> &str &CStr &OsStr &Path &[u8] Other

If you have x of type ... Use this ...

String x

CString x.into_string()?

OsString x.to_str()?.to_string()

PathBuf x.to_str()?.to_string()

Vec<u8> 1 String::from_utf8(x)?
i
&str x.to_string()

&CStr x.to_str()?.to_string()

&OsStr x.to_str()?.to_string()

&Path x.to_str()?.to_string()

&[u8] 1 String::from_utf8_lossy(x).to_string()

i
Short form x.into() possible if type can be inferred.
r
Short form x.as_ref() possible if type can be inferred.

1
You should, or must if call is unsafe , ensure raw data comes with a valid representation for the string type (e.g., UTF-8 data for a String ).

2
Only on some platforms std::os::<your_os>::ffi::OsStrExt exists with helper methods to get a raw &[u8] representation of the underlying OsStr . Use the rest of
the table to go from there, e.g.:

use std::os::unix::ffi::OsStrExt;
let bytes: &[u8] = my_os_str.as_bytes();
CString::new(bytes)?

3
The c_char must have come from a previous CString . If it comes from FFI see &CStr instead.

String Formatting
Formatting applies to print! , eprint! , write! (and their - ln siblings like println! ). Each format argument is either empty {} ,
{argument} , or follows a basic syntax:

{ [argument] ':' [[fill] align] [sign] ['#'] [width [$]] ['.' precision [$]] [type] }

Element Meaning
argument Number ( 0 , 1 , ...) or argument name, e.g., print!("{x}", x = 3) .

fill The character to ll empty spaces with (e.g., 0 ), if width is speci ed.

align Left ( < ), center ( ^ ), or right ( > ), if width is speci ed.

sign Can be + for sign to always be printed.

# Alternate formatting, e.g. prettify Debug ? or pre x hex with 0x .

width Minimum width (≥ 0), padding with fill (default to space). If starts with 0 , zero-padded.

precision Decimal digits (≥ 0) for numerics, or max width for non-numerics.

$ Interpret width or precision as argument identi er instead to allow for dynamic formatting.

type Debug ( ? ) formatting, hex ( x ), binary ( b ), octal ( o ), pointer ( p ), exp ( e ) ... see more.
 
Example Explanation
{:?} Print the next argument using Debug.

{2:#?} Pretty-print the 3rd argument with Debug formatting.

{val:^2$} Center the val named argument, width speci ed by the 3rd argument.

https://cheats.rs/#printing-pdf 10/16
21/08/2020 Rust Language Cheat Sheet

Example Explanation
{:<10.3} Left align with width 10 and a precision of 3.

{val:#x} Format val argument as hex, with a leading 0x (alternate format for x ).
 

Tooling

Project Anatomy
Basic project layout, and common les and folders, as used by cargo . ↓

Entry Code
📁 benches/ Benchmarks for your crate, run via cargo bench , requires nightly by default. * 🚧

📁 examples/ Examples how to use your crate, they see your crate like external user would.

     my_example.rs Individual examples are run like cargo run --example my_example .

📁 src/ Actual source code for your project.

     build.rs Pre-build script 🔗, e.g., when compiling C / FFI, needs to be speci ed in Cargo.toml .

     main.rs Default entry point for applications, this is what cargo run uses.

     lib.rs Default entry point for libraries. This is where lookup for my_crate::f() starts.

📁 tests/ Integration tests go here, invoked via cargo test . Unit tests often stay in src/ le.

.rustfmt.toml In case you want to customize how cargo fmt works.

.clippy.toml Special con guration for certain clippy lints, utilized via cargo clippy

Cargo.toml Main project con guration. De nes dependencies, artifacts ...

Cargo.lock Dependency details for reproducible builds, recommended to git for apps, not for libs.
* On stable consider Criterion.

 
 
Modules BK EX REF and source les work as follows:

Module tree needs to be explicitly de ned, is not implicitly built from le system tree. 🔗
Module tree root equals library, app, ... entry point (e.g., lib.rs ).
A mod m {} de nes module in- le, while mod m; will read m.rs or m/mod.rs .
Path of .rs based on nesting, e.g., mod a { mod b { mod c; }}} is either a/b/c.rs or a/b/c/mod.rs .
Files not pathed from module tree root via some mod m; won't be touched by compiler! 🛑

Cargo
Commands and tools that are good to know.

Command Description
cargo init Create a new project for the latest edition.

cargo b uild Build the project in debug mode ( --release for all optimization).

cargo c heck Check if project would compile (much faster).

cargo t est Run tests for the project.

cargo r un Run your project, if a binary is produced (main.rs).

     cargo run --bin b Run binary b . Uni es features with other dependents (can be confusing).

     cargo run -p w Run main of sub-workspace w . Treats features more as you would expect.

https://cheats.rs/#printing-pdf 11/16
21/08/2020 Rust Language Cheat Sheet

Command Description
cargo doc --open Locally generate documentation for your code and dependencies.

cargo rustc -- -Zunpretty=X Show more desugared Rust code, in particular with X being:

     expanded Show with expanded macros, ...

cargo +{nightly, stable} ... Runs command with given toolchain, e.g., for 'nightly only' tools.

rustup doc Open o ine Rust documentation (incl. the books), good on a plane!

A command like cargo b uild means you can either type cargo build or just cargo b .

 
These are optional rustup components. Install them with rustup component add [tool] .

Tool Description
cargo clippy Additional (lints) catching common API misuses and unidiomatic code. 🔗

cargo fmt Automatic code formatter ( rustup component add rustfmt ). 🔗

 
A large number of additional cargo plugins can be found here.

Cross Compilation
🔘 Check target is supported.

🔘 Install target via rustup target install X .

🔘 Install native toolchain (required to link, depends on target).

Get from target vendor (Google, Apple, ...), might not be available on all hosts (e.g., no iOS toolchain on Windows).

Some toolchains require additional build steps (e.g., Android's make-standalone-toolchain.sh ).

🔘 Update ~/.cargo/config.toml like this:

[target.aarch64-linux-android]
linker = "[PATH_TO_TOOLCHAIN]/aarch64-linux-android/bin/aarch64-linux-android-clang"

or

[target.aarch64-linux-android]
linker = "C:/[PATH_TO_TOOLCHAIN]/prebuilt/windows-x86_64/bin/aarch64-linux-android21-clang.cmd"

🔘 Set environment variables (optional, wait until compiler complains before setting):

set CC=C:\[PATH_TO_TOOLCHAIN]\prebuilt\windows-x86_64\bin\aarch64-linux-android21-clang.cmd
set AR=C:\[PATH_TO_TOOLCHAIN]\prebuilt\windows-x86_64\bin\aarch64-linux-android-ar.exe
...

Whether you set them depends on how compiler complains, not necessarily all are needed.

Some platforms / con gurations can be extremely sensitive how paths are speci ed (e.g., \ vs / ) and quoted.

✔ Compile with cargo build --target=X

Coding Guides

https://cheats.rs/#printing-pdf 12/16
21/08/2020 Rust Language Cheat Sheet

Idiomatic Rust
If you are used to programming Java or C, consider these.

Idiom Code
Think in Expressions x = if x { a } else { b };

x = loop { break 5 };

fn f() -> u32 { 0 }

Think in Iterators (1..10).map(f).collect()

names.iter().filter(|x| x.starts_with("A"))

Handle Absence with ? x = try_something()?;

get_option()?.run()?

Use Strong Types enum E { Invalid, Valid { ... } } over ERROR_INVALID = -1

enum E { Visible, Hidden } over visible: bool

struct Charge(f32) over f32

Provide Builders Car::new("Model T").hp(20).build();

Split Implementations Generic types S<T> can have a separate impl per T .

Rust doesn't have OO, but with separate impl you can get specialization.

Unsafe Avoid unsafe {} , often safer, faster solution without it. Exception: FFI.

Implement Traits #[derive(Debug, Copy, ...)] and custom impl where needed.

Tooling With clippy you can improve your code quality.

Formatting with rustfmt helps others to read your code.
Add unit tests BK ( #[test] ) to ensure your code works.

Add doc tests BK ( ``` my_api::f() ``` ) to ensure docs match code.

Documentation Annotate your APIs with doc comments that can show up on docs.rs.
Don't forget to include a summary sentence and the Examples heading.
If applicable: Panics, Errors, Safety, Abort and Unde ned Behavior.
 

🔥 We highly recommend you also follow the API Guidelines (Checklist) for any shared project! 🔥

Async-Await 101
If you are familiar with async / await in C# or TypeScript, here are some things to keep in mind:

Basics Execution Flow Caveats

Construct Explanation
async Anything declared async always returns an impl Future<Output=_> . STD
     async fn f() {} Function f returns an impl Future<Output=()> .
    
Function f returns an impl Future<Output=S> .
async fn f() -> S {}

     async { x } Transforms { x } into an impl Future<Output=X> .

Calling f() that is async will not execute f , but produce state machine
let sm = f();
sm . 12

    
Likewise, does not execute the { g() } block; produces state machine.
sm = async { g() };

https://cheats.rs/#printing-pdf 13/16
21/08/2020 Rust Language Cheat Sheet

Construct Explanation
Outside an async {} , schedules sm to actually run. Would execute g() . 3
runtime.block_on(sm);
4

Inside an async {} , run sm until complete. Yield to runtime if sm not

sm.await
ready.
1 Technically async transforms following code into anonymous, compiler-generated state machine type; f() instantiates that
machine.
2
The state machine always impl Future , possibly Send & co, depending on types used inside async .
3 State machine driven by worker thread invoking Future::poll() via runtime directly, or parent .await indirectly.

4
Rust doesn't come with runtime, need external crate instead, e.g., async-std or tokio 0.2+. Also, more helpers in futures crate.

Closures in APIs
There is a subtrait relationship Fn : FnMut : FnOnce . That means a closure that implements Fn STD
also implements FnMut and FnOnce .
Likewise a closure that implements FnMut STD
also implements FnOnce . STD

From a call site perspective that means:

Signature Function g can call ... Function g accepts ...

g<F: FnOnce()>(f: F) ... f() once. Fn , FnMut , FnOnce

g<F: FnMut()>(mut f: F) ... f() multiple times. Fn , FnMut

g<F: Fn()>(f: F) ... f() multiple times. Fn

Notice how asking for a Fn closure as a function is most restrictive for the caller; but having a Fn closure as a caller is most compatible with any function.

 
From the perspective of someone de ning a closure:

Closure Implements* Comment

|| { moved_s; } FnOnce Caller must give up ownership of moved_s .

|| { &mut s; } FnOnce , FnMut Allows g() to change caller's local state s .

|| { &s; } FnOnce , FnMut , Fn May not mutate state; but can share and reuse s .
*
Rust prefers capturing by reference (resulting in the most "compatible" Fn closures from a caller perspective), but can be forced to
capture its environment by copy or move via the move || {} syntax.

 
That gives the following advantages and disadvantages:

Requiring Advantage Disadvantage

F: FnOnce Easy to satisfy as caller. Single use only, g() may call f() just once.

F: FnMut Allows g() to change caller state. Caller may not reuse captures during g() .

F: Fn Many can exist at same time. Hardest to produce for caller.

 

Unsafe, Unsound, Unde ned

Unsafe leads to unsound. Unsound leads to unde ned. Unde ned leads to the dark side of the force.

Unsafe Code Unde ned Behavior Unsound Code

Unsafe Code

Code marked unsafe has special permissions, e.g., to deref raw pointers, or invoke other unsafe
functions.

https://cheats.rs/#printing-pdf 14/16
21/08/2020 Rust Language Cheat Sheet

Along come special promises the author must uphold to the compiler, and the compiler will
trust you.
By itself unsafe code is not bad, but dangerous, and needed for FFI or exotic data structures.

// `x` must always point to race-free, valid, aligned, initialized u8 memory.

unsafe fn unsafe_f(x: *mut u8) {
my_native_lib(x);
}

Responsible use of Unsafe

Do not use unsafe unless you absolutely have to.

Follow the Nomicon, Unsafe Guidelines, always uphold all safety invariants, and never invoke UB.
Minimize the use of unsafe and encapsulate it in small, sound modules that are easy to review.
Each unsafe unit should be accompanied by plain-text reasoning outlining its safety.

API Stability
When updating an API, these changes can break client code, compare RFC 1105. Major changes (🔴) are de nitely breaking, while
minor changes ( ) might be breaking:

 
Crates
🔴 Making a crate that previously compiled for stable require nightly.
Altering use of Cargo features (e.g., adding or removing features).
 
Modules
🔴 Renaming / moving / removing any public items.
Adding new public items, as this might break code that does use your_crate::* .
 
Structs
🔴 Adding private eld when all current elds public.
🔴 Adding public eld when no private eld exists.
Adding or removing private elds when at least one already exists (before and after the change).
Going from a tuple struct with all private elds (with at least one eld) to a normal struct, or vice versa.
 
Enums
🔴 Adding new variants.
🔴 Adding new elds to a variant.
 
Traits
🔴 Adding a non-defaulted item, breaks all existing impl T for S {} .

🔴 Any non-trivial change to item signatures, will a ect either consumers or implementors.
Adding a defaulted item; might cause dispatch ambiguity with other existing trait.
Adding a defaulted type parameter.
 
Traits
🔴 Implementing any "fundamental" trait, as not implementing a fundamental trait already was a promise.
Implementing any non-fundamental trait; might also cause dispatch ambiguity.

https://cheats.rs/#printing-pdf 15/16
21/08/2020 Rust Language Cheat Sheet
 
Inherent Implementations
Adding any inherent items; might cause clients to prefer that over trait fn and produce compile error.
 
Signatures in Type De nitions
🔴 Tightening bounds (e.g., <T> to <T: Clone> ).

Loosening bounds.
Adding defaulted type parameters.
Generalizing to generics.
Signatures in Functions
🔴 Adding / removing arguments.
Introducing a new type parameter.
Generalizing to generics.
 
Behavioral Changes
🔴/ Changing semantics might not cause compiler errors, but might make clients do wrong thing.
 
Ralf Biedert, 2020 – cheats.rs

Legal & Privacy

https://cheats.rs/#printing-pdf 16/16