Rust-fusklapp
En sökbar, utskrivbar Rust-referens: ownership och borrowing, traits, mönstermatchning, Option och Result, iteratorer och Cargo. Gratis.
Basics
10let x = 5;
Immutable binding (default)
let mut count = 0; count += 1;
Mutable binding
let x = "5"; let x: i32 = x.parse()?;
Shadowing (new type allowed)
i32, u64, f64, bool, char, usize
Core scalar types
let t = (1, "a"); t.0
Tuple + field access
let a = [0u8; 16];
Fixed array of 16 zeros
const MAX_USERS: u32 = 100;
Compile-time constant
let n = big as u8;
Explicit numeric cast
let s: String; let sl: &str;
Owned string vs string slice
println!("{name} has {count}");
Inline variable interpolation
Ownership, borrowing & lifetimes
10let b = a; // a is moved
Assignment moves non-Copy types
let b = a.clone();
Deep copy keeps both usable
fn read(s: &String) / read(&s)
Shared borrow (many allowed)
fn edit(s: &mut String) / edit(&mut s)
Exclusive borrow (only one)
// no &mut while & borrows live
The core borrow rule
fn greet(name: &str)
Prefer &str params over &String
i32, bool, char, &T are Copy
Copy types never move
fn first<'a>(a: &'a str, b: &str) -> &'a str
Tie output to an input lifetime
struct View<'a> { text: &'a str }
Struct holding a reference
let s: &'static str = "literal";
Lives for the whole program
Structs, enums & impl
10struct User { name: String, age: u32 }
Struct definition
let u = User { name, age: 30 };
Literal + field-init shorthand
let u2 = User { age: 31, ..u };
Struct update syntax
struct Meters(f64);
Tuple struct (newtype idiom)
impl User { fn new(name: String) -> Self { ... } }
Associated constructor
fn label(&self) -> String
Method borrowing self
fn rename(&mut self, n: String)
Method mutating self
enum Shape { Circle(f64), Rect { w: f64, h: f64 } }
Enum with data per variant
#[derive(Debug, Clone, PartialEq)]
Auto-implement common traits
let cfg = Config::default();
Default trait construction
Pattern matching
10match n { 0 => "zero", _ => "other" }
Exhaustive match expression
match shape { Shape::Circle(r) => ... }
Destructure enum variants
match n { 1..=5 => "low", _ => "high" }
Range patterns
match p { Point { x, y: 0 } => ... }
Destructure struct fields
Some(n) if n > 10 => "big"
Match guard
id @ 1..=9 => use(id)
Bind while matching (@)
if let Some(v) = opt { use(v); }
Match a single pattern
let Some(v) = opt else { return; };
let-else early exit
while let Some(x) = stack.pop() { ... }
Loop while a pattern holds
matches!(status, Status::Active)
Boolean pattern test macro
Option & Result
12let opt: Option<i32> = Some(5);
Maybe-a-value type
let res: Result<T, E> = Ok(v);
Success-or-error type
let v = load()?;
? propagates None / Err up
opt.unwrap_or(0)
Value or a default
opt.unwrap_or_else(|| compute())
Lazy default
opt.unwrap_or_default()
Value or Default::default()
opt.map(|v| v * 2)
Transform if present
opt.and_then(|v| v.checked_mul(2))
Chain fallible steps (flatMap)
opt.ok_or(MyError::Missing)?
Option → Result
res.map_err(|e| AppError::Io(e))
Convert the error type
opt.is_some(); res.is_err();
Cheap state checks
let v = opt.take();
Move out, leave None behind
Traits & generics
11trait Greet { fn hello(&self) -> String; }
Trait: shared behavior
trait Greet { fn wave(&self) { ... } }
Default method body
impl Greet for User { ... }
Implement for a type
fn welcome<T: Greet>(x: &T)
Generic with a trait bound
fn f<T>(x: T) where T: Greet + Clone
where clause for many bounds
fn welcome(x: &impl Greet)
impl Trait argument sugar
fn make() -> impl Iterator<Item = u32>
Opaque return type
let objs: Vec<Box<dyn Greet>> = ...;
Trait objects (dynamic dispatch)
impl From<u32> for Meters { ... }
From gives you Into for free
let m: Meters = 5u32.into();
Convert via Into
impl fmt::Display for User { ... }
Custom {} formatting
Collections
12let mut v = vec![1, 2, 3];
Vec literal macro
v.push(4); v.pop();
Append / remove last
v.get(0) // Option<&T>
Safe indexing (v[9] panics)
for x in &v { ... }
Iterate by reference
v.sort(); v.sort_by_key(|u| u.age);
In-place sorting
v.retain(|x| *x > 0);
Keep matching elements
let mut m = HashMap::new(); m.insert(k, v);
Hash map basics
*counts.entry(word).or_insert(0) += 1;
Entry API counter idiom
m.contains_key(&k); m.get(&k);
Lookups return Option
s.push_str("more"); format!("{a}{b}")
Grow / build strings
s.chars().rev().collect::<String>()
Char-wise string processing
names.join(", ")
Join a Vec<String>
Iterators & closures
14v.iter().map(|x| x * 2).collect::<Vec<_>>()
Transform and materialize
.filter(|x| **x > 0)
Keep matching elements
.filter_map(|s| s.parse().ok())
Filter + map in one pass
.sum::<i32>(); .count(); .max()
Common consumers
.fold(0, |acc, x| acc + x)
General reduction
.enumerate()
Pairs of (index, item)
.zip(other.iter())
Walk two iterators together
.take(5); .skip(2); .rev()
Slice and reverse lazily
.flat_map(|l| l.split(' '))
Map then flatten
.any(|x| x < 0); .all(|x| x > 0)
Short-circuit predicates
.find(|u| u.id == id); .position(...)
First match / its index
iter() &T; iter_mut() &mut T; into_iter() T
The three iteration modes
let add = move |x| x + base;
move closure takes ownership
.collect::<HashMap<_, _>>()
Collect pairs into a map
Error handling
11fn run() -> Result<(), Box<dyn Error>>
Quick catch-all error type
fn main() -> anyhow::Result<()>
anyhow for applications
file.read().context("reading config")?;
anyhow: attach context
anyhow::bail!("invalid input: {x}");
Early return with an error
#[derive(thiserror::Error, Debug)]
thiserror for libraries
#[error("user {0} not found")] NotFound(u64),
Display message per variant
#[error(transparent)] Io(#[from] std::io::Error),
Auto-From wrapped errors
enum AppError { Db(String), Timeout }
Custom error enum
let n = do_it()?; // Err auto-converts
? uses From between error types
opt.expect("config must be loaded")
unwrap/expect: tests only
eprintln!("error: {e:#}");
Print the full error chain
Smart pointers & interior mutability
11let b = Box::new(BigStruct::new());
Heap allocation, sole owner
enum List { Node(i32, Box<List>), Nil }
Box enables recursive types
let a = Rc::new(data); let b = Rc::clone(&a);
Shared owner, single thread
let a = Arc::new(data);
Shared owner across threads
let c = RefCell::new(0); *c.borrow_mut() += 1;
Runtime-checked mutation
Rc<RefCell<T>>
Shared + mutable (one thread)
let m = Mutex::new(0); *m.lock().unwrap() += 1;
Thread-safe mutation
Arc<Mutex<T>>
Shared + mutable across threads
let l = RwLock::new(map); l.read(); l.write();
Many readers or one writer
Cell::new(5).set(6);
Copy-type interior mutability
let w = Rc::downgrade(&a); w.upgrade()
Weak breaks reference cycles
Concurrency & async
13let h = thread::spawn(|| work()); h.join()
Spawn and join a thread
thread::spawn(move || use(data))
move data into the thread
thread::scope(|s| { s.spawn(|| ...); })
Borrow locals in threads
let (tx, rx) = mpsc::channel();
Multi-producer channel
tx.send(job)?; let job = rx.recv()?;
Send / blocking receive
let n = Arc::new(Mutex::new(0));
Shared counter pattern
#[tokio::main] async fn main() { ... }
Async runtime entry point
async fn fetch() -> Result<Data>
Async function
let data = fetch().await?;
Await a future
let h = tokio::spawn(fetch()); h.await??;
Spawn an async task
let (a, b) = tokio::join!(f1(), f2());
Run futures concurrently
tokio::time::sleep(Duration::from_secs(1)).await;
Non-blocking sleep
tokio::select! { r = f1() => ..., _ = f2() => ... }
First future to finish wins
Cargo CLI
12cargo new my-app
Create a binary project
cargo add serde --features derive
Add a dependency
cargo run
Build and run (debug)
cargo build --release
Optimized build
cargo check
Type-check fast, no binary
cargo test
Run tests (+ doc tests)
cargo clippy -- -D warnings
Lints, warnings as errors
cargo fmt
Format the whole project
cargo doc --open
Build and browse the docs
cargo update
Refresh Cargo.lock versions
cargo install ripgrep
Install a binary crate
cargo tree
Show the dependency graph
Ingen post matchar “:q”.
Om Rust-fusklapp
Den här Rust-fusklappen kartlägger språket efter begrepp på en sökbar sida: grunder, ownership, borrowing och lifetimes, structs, enums och impl-block, mönstermatchning, Option och Result, traits och generics, samlingar, iteratorer och closures, felhantering, smarta pekare och interior mutability, samtidighet och async samt kommandoraden för Cargo.
Ownership är det man ofta kommer tillbaka för att slå upp i Rust, så det har ett eget avsnitt bredvid lifetimes, lånereglerna, Box, Rc, Arc och RefCell, vid sidan av vardagssyntax som match-grenar, operatorn ?, iteratoradaptrar och deriving av traits.
Som alla fusklappar i den här gruppen är den gratis och körs i klienten: filtrera rader direkt med sökrutan, hoppa mellan avsnitt med den fasta innehållsförteckningen, kopiera valfritt kodexempel med ett klick och skriv ut sidan som skrivbordsreferens.
Så använder du Rust-fusklapp
- Öppna bladet och gå igenom avsnitten, från Grunder och Ownership & borrowing till Cargo CLI.
- Sök efter ett nyckelord som lifetime, match eller Arc för att filtrera bladet direkt.
- Hoppa till Option & Result eller Felhantering när du behöver det idiomatiska sättet att hantera fel.
- Klicka på ett kodexempel eller dess kopieringsikon för att kopiera Rust-koden till urklipp.
- Använd Skriv ut för en pappersversion av hela Rust-referensen.
Vanliga frågor
Tolv avsnitt: grunder, ownership, borrowing och lifetimes, structs, enums och impl, mönstermatchning, Option och Result, traits och generics, samlingar, iteratorer och closures, felhantering, smarta pekare och interior mutability, samtidighet och async samt Cargo CLI.
Ja. Ett eget avsnitt visar moves, lån, muterbara lån, lånekontrollantens regler och lifetime-annoteringar, med korta förklaringar på varje rad.
Ja: kombinatorer för Option och Result, operatorn ?, egna feltyper, From-konverteringar och vanliga crate-mönster visas som kopieringsklara kodexempel.
Ja. Klicka på koden på valfri rad eller på dess kopieringsikon, så kopieras den direkt.
Ja, den är helt gratis och körs i webbläsaren utan inloggning.
Populära sökningar
rust fusklapp
rust syntax referens
rust ownership och borrowing
rust lifetimes förklarat
option och result rust
rust traits och generics
cargo kommandon
Behöver du hjälp?
Hittade du ett problem med det här verktyget? Berätta för oss.