Rust চিট শিট

বিনামূল্যে

একটি অনুসন্ধানযোগ্য, প্রিন্টযোগ্য Rust রেফারেন্স: ownership ও borrowing, ট্রেইট, প্যাটার্ন ম্যাচিং, Option ও Result, ইটারেটর এবং Cargo। বিনামূল্যে।

Basics

let 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

let 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

struct 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

match 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

let 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

trait 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

let 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

v.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

fn 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

let 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

let 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

cargo 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

“:q”-এর সাথে কোনো এন্ট্রি মেলে না।

Rust চিট শিট সম্পর্কে

এই Rust চিট শিট ভাষাটিকে একটি অনুসন্ধানযোগ্য পৃষ্ঠায় ধারণা অনুযায়ী ম্যাপ করে: বেসিক, ownership, borrowing ও lifetime, স্ট্রাক্ট, enum ও impl ব্লক, প্যাটার্ন ম্যাচিং, Option ও Result, ট্রেইট ও জেনেরিক, কালেকশন, ইটারেটর ও ক্লোজার, error handling, স্মার্ট পয়েন্টার ও interior mutability, concurrency ও async, এবং Cargo কমান্ড লাইন।

Ownership হলো Rust-এর সেই অংশ যা মানুষ বারবার দেখতে ফিরে আসে, তাই এটি lifetime, borrowing নিয়ম, Box, Rc, Arc এবং RefCell-এর পাশে নিজস্ব বিভাগ পায়: match arm, ? অপারেটর, ইটারেটর অ্যাডাপ্টার ও ট্রেইট derive করার মতো দৈনন্দিন সিনট্যাক্সের পাশাপাশি।

এই গ্রুপের প্রতিটি চিট শিটের মতোই এটি বিনামূল্যে এবং ক্লায়েন্ট-সাইড: সার্চ বক্স দিয়ে লাইভ সারি ফিল্টার করুন, স্টিকি সূচিপত্র দিয়ে বিভাগগুলোর মধ্যে লাফ দিন, এক ক্লিকে যেকোনো স্নিপেট কপি করুন এবং একটি ডেস্ক রেফারেন্স হিসেবে পৃষ্ঠাটি প্রিন্ট করুন।

Rust চিট শিট কীভাবে ব্যবহার করবেন

শিটটি খুলুন এবং বিভাগগুলো পর্যালোচনা করুন, Basics ও Ownership & borrowing থেকে Cargo CLI পর্যন্ত।
শিটটি লাইভ ফিল্টার করতে lifetime, match বা Arc-এর মতো একটি কীওয়ার্ড অনুসন্ধান করুন।
ব্যর্থ হওয়ার idiomatic উপায় প্রয়োজন হলে Option & Result বা Error handling-এ যান।
Rust কোড আপনার ক্লিপবোর্ডে কপি করতে একটি স্নিপেট বা এর কপি আইকনে ক্লিক করুন।
সম্পূর্ণ Rust রেফারেন্সের একটি কাগজের কপির জন্য Print ব্যবহার করুন।

সচরাচর জিজ্ঞাসিত প্রশ্ন

বারোটি বিভাগ: বেসিক, ownership, borrowing ও lifetime, স্ট্রাক্ট, enum ও impl, প্যাটার্ন ম্যাচিং, Option ও Result, ট্রেইট ও জেনেরিক, কালেকশন, ইটারেটর ও ক্লোজার, error handling, স্মার্ট পয়েন্টার ও interior mutability, concurrency ও async, এবং Cargo CLI।

হ্যাঁ। একটি নিবেদিত বিভাগ move, borrow, mutable borrow, borrow-checker নিয়ম এবং lifetime অ্যানোটেশন প্রতিটি সারিতে সংক্ষিপ্ত ব্যাখ্যাসহ দেখায়।

করে: Option ও Result কম্বিনেটর, ? অপারেটর, কাস্টম error টাইপ, From কনভার্শন এবং সাধারণ crate প্যাটার্ন প্রতিটি কপি-রেডি স্নিপেট হিসেবে দেখা যায়।

হ্যাঁ। যেকোনো সারিতে কোড বা এর কপি আইকনে ক্লিক করুন এবং এটি অবিলম্বে কপি হয়ে যায়।

হ্যাঁ, এটি সম্পূর্ণ বিনামূল্যে এবং কোনো লগইন ছাড়াই আপনার ব্রাউজারে চলে।

Rust চিট শিট

Basics

Ownership, borrowing & lifetimes

Structs, enums & impl

Pattern matching

Option & Result

Traits & generics

Collections

Iterators & closures

Error handling

Smart pointers & interior mutability

Concurrency & async

Cargo CLI

Rust চিট শিট সম্পর্কে

Rust চিট শিট কীভাবে ব্যবহার করবেন

সচরাচর জিজ্ঞাসিত প্রশ্ন

Rust চিট শিটে কী রয়েছে?

এটি কি ownership এবং borrowing ব্যাখ্যা করে?

এটি কি error handling কভার করে?

আমি কি এক ক্লিকে একটি স্নিপেট কপি করতে পারি?

Rust রেফারেন্স কি বিনামূল্যে?

সম্পর্কিত টুলসমূহ

জনপ্রিয় অনুসন্ধান

এই টুলটি এম্বেড করুন