RUSTCS

v0.0.1

Rust Cheat Sheet

Nodes: 46 Active

Tiers: 3 Vertical

Export: Static SSG

Types & OS Primitives

01Basic

Fixed-size contiguous stack array allocations and dynamic slice views representing safe subsets.

Logical boolean primitives representing true or false states for conditions and control flow.

32-bit Unicode scalar character primitives supporting all international symbols, glyphs, and emojis.

IEEE 754 single and double precision floating-point scalar numbers for mathematical operations.

Standard signed and unsigned 32-bit integers, representing base scalar numbers.

Fixed-size heterogeneous compound structures and the empty zero-sized unit type for simple clustering.

02Std

Owned heap-allocated string buffer (String) vs immutable borrowed string slice (&str).

Pointer-sized unsigned integer representing container indexes and raw sizes.

03Sys

OsString / OsStr

Native OS-compatible string buffers bypassing strict UTF-8 rules.

Cross-platform filesystem path representations for config and resource management.

*const T / *mut T

Raw constant and mutable pointers bypassing borrow checker rules for low-level FFI.

Data Structures & Collections

01Basic

Basic enumerated types representing explicit variants for branching.

Custom compound types: Named-field structs, Tuple structs, and Unit structs.

02Std

Lazy sequence processing via the Iterator trait with powerful functional adapters.

Safe tracking of value presence (Some(T)) or absence (None) without null pointers.

Success (Ok(T)) or failure (Err(E)) return tracking preventing unhandled exceptions.

Vec<T> / HashMap

Dynamically resizable array vectors (Vec) and Key-Value hash structures (HashMap).

03Sys

Data-carrying enum sum types representing complex nested polymorphic action structures.

Control Flow & Context Routing

01Basic

Conditional evaluation logic branches returning type-safe values directly.

loop / while / for

Infinite evaluation loops, conditional while iterations, and zero-cost sequence iterators.

02Std

Concise block execution matching a single target variant pattern.

Exhaustive destructuring and evaluation of compound structures or variants.

03Sys

Context-sensitive inline evaluations validating environment states during match dispatching.

Memory, Safety & OS Hooks

01Basic

Ownership & Moves

Value consumption and ownership transfer metrics preventing double frees.

References & Borrowing

Shared references (&T) vs exclusive mutable references (&mut T) protecting against data races.

02Std

Explicit single-owner heap-allocated pointer wrapper for recursive data and trait objects.

Explicit compilation parameters tracking reference validity scopes to block dangling pointers.

Single-threaded reference-counted smart pointer enabling shared read-only heap ownership.

Core smart pointer interfaces allowing custom pointer types and resource cleanup hooks.

03Sys

Thread-safe atomic reference counter tracking multi-thread read-only structures.

Interior mutability containers enabling values to be mutated even when held by immutable references.

Locks providing safe interior mutability across concurrent thread boundaries.

Explicit blocks bypassing standard compiler safety to write low-level OS hooks.

Functions, Closures & Extens.

01Basic

Associated Methods

Execution blocks encapsulated within a struct context using self parameters.

Standard structural execution procedures with strictly enforced compile-time parameter signatures.

02Std

In-flight anonymous functions capturing environment variables.

Built-in Traits

Derivable trait behaviors defining standard operations like Clone, Copy, and Debug.

03Sys

Shared abstract interfaces defining plugin systems and static/dynamic dispatch mechanisms.

Parametric types compiling into direct monomorphized machine variants.

Concurrency & OS Execution

01Basic

Modules / Crates

Internal workspace layouts (mod, use, pub) managing compilation symbols and visibility.

Streamlined error propagation mechanism bubbling issues up execution chains.

02Std

Declarative Macros

Code-generating text expansions executed entirely during compilation.

Command Invocations

Invoking native binaries or system shells directly from code using Command builders.

03Sys

Asynchronous state-machine concurrency using Futures and cooperative yield loops.

Multi-producer, single-consumer communication channels transmitting safe cross-thread events.

Thread Spawning

Spawning operating-system-level parallel worker execution loops.