🦀 Complete Rust Reference

// Declarative macros
macro_rules! vec_of_squares {
($($x:expr),*) => {
    vec![$($x * $x),*]
};
}

// Procedural macros
#[derive(Debug, Clone)]           // Derive macro
#[serde(rename_all = "camelCase")] // Attribute macro
struct Point {
x: f64,
y: f64,
}

// Custom derive macro
#[proc_macro_derive(MyTrait)]
pub fn my_trait_derive(input: TokenStream) -> TokenStream {
// Implementation
}

// Common standard macros
println!("Formatted {}", string);
format!("Format without printing {}", string);
vec![1, 2, 3];
assert!(condition);
assert_eq!(left, right);
include_str!("file.txt");

// Builder Pattern
struct RequestBuilder {
url: String,
method: String,
headers: HashMap<String, String>,
}

impl RequestBuilder {
fn new(url: &str) -> Self {
    // Implementation
}

fn method(mut self, method: &str) -> Self {
    self.method = method.to_string();
    self
}
}

// Type-State Pattern
struct Connection<State> {
state: PhantomData<State>,
}

impl<State> Connection<State> {
fn connect(self) -> Connection<Connected> {
    // Implementation
}
}

// RAII Pattern
struct ResourceGuard<T> {
resource: T,
}

impl<T> Drop for ResourceGuard<T> {
fn drop(&mut self) {
    // Cleanup
}
}

// Message Passing
use std::sync::mpsc;
let (tx, rx) = mpsc::channel();

crossbeam::scope(|scope| {
scope.spawn(move |_| {
    tx.send(42).unwrap();
});
});

// Mutex Pool
let data = Arc::new(Mutex::new(vec![]));
let data_clone = Arc::clone(&data);

// Async Actor Pattern
struct Actor {
receiver: mpsc::Receiver<Message>,
state: ActorState,
}

impl Actor {
async fn run(&mut self) {
    while let Some(msg) = self.receiver.recv().await {
        self.handle_message(msg).await;
    }
}
}

// Foreign Function Interface
#[link(name = "my_c_lib")]
extern "C" {
fn c_function(x: i32) -> i32;
}

// Unsafe block
unsafe {
let ptr = &num as *const i32;
println!("Location: {:?}", ptr);
}

// Raw pointers
let mut num = 5;
let r1 = &num as *const i32;
let r2 = &mut num as *mut i32;

// Unsafe trait
unsafe trait Scary { }
unsafe impl Scary for i32 { }

// HTTP Client with reqwest
let response = reqwest::Client::new()
.get("https://api.example.com")
.header("Authorization", "Bearer token")
.send()
.await?;

// TCP Server
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<()> {
let listener = TcpListener::bind("127.0.0.1:8080").await?;

while let Ok((socket, _)) = listener.accept().await {
    tokio::spawn(async move {
        process_socket(socket).await
    });
}
}

// WebSocket Client
use tokio_tungstenite;

let (ws_stream, _) = connect_async("ws://localhost:8080")
.await?;

// SQLx with PostgreSQL
let pool = PgPoolOptions::new()
.max_connections(5)
.connect("postgres://user:pass@localhost/db").await?;

let row: (i64,) = sqlx::query_as(
"SELECT $1"
)
.bind(150_i64)
.fetch_one(&pool).await?;

// Diesel ORM
#[derive(Queryable)]
struct Post {
id: i32,
title: String,
body: String,
}

diesel::insert_into(posts::table)
.values(&new_post)
.execute(&mut conn)?;

// Cargo commands
cargo new project_name
cargo build --release
cargo test -- --nocapture
cargo bench
cargo doc --open
cargo clippy
cargo fmt

// Workspace setup
// Cargo.toml
[workspace]
members = [
"core",
"cli",
"web",
]

// Features
[features]
default = ["std"]
std = []
alloc = []

// Development dependencies
[dev-dependencies]
criterion = "0.3"
mockall = "0.11"
tokio-test = "0.4"

// Modern derive-based approach with Clap
use clap::Parser;

#[derive(Parser)]
#[command(author, version, about)]
struct Cli {
// Optional parameter with default
#[arg(short, long, default_value = "default")]
name: String,

// Required parameter
#[arg(short, long)]
count: usize,

// Flag (boolean)
#[arg(short, long)]
verbose: bool,

// Multiple values
#[arg(short, long, num_args = 1..)]
files: Vec<PathBuf>,

// Subcommand
#[command(subcommand)]
command: Option<Commands>,
}

#[derive(Subcommand)]
enum Commands {
Add {
    name: String,
},
Remove {
    #[arg(short, long)]
    force: bool,
},
}

// Usage example
fn main() {
let cli = Cli::parse();

match cli.command {
    Some(Commands::Add { name }) => {
        println!("Adding {}", name);
    }
    Some(Commands::Remove { force }) => {
        println!("Removing with force = {}", force);
    }
    None => {}
}
}

// Define serializable structures
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct User {
user_id: u64,
#[serde(rename = "displayName")]
name: String,
#[serde(default)]
active: bool,
#[serde(skip_serializing_if = "Option::is_none")]
email: Option<String>,
#[serde(flatten)]
metadata: HashMap<String, Value>,
}

// JSON processing
fn process_json() -> Result<()> {
// Parse JSON string
let json_str = r#"{"userId": 1, "name": "John"}"#;
let user: User = serde_json::from_str(json_str)?;

// Work with dynamic JSON
let value: Value = serde_json::from_str(json_str)?;
println!("Name: {}", value["name"]);

// Serialize to string
let json = serde_json::to_string_pretty(&user)?;

// Stream JSON processing
use serde_json::Deserializer;
let stream = Deserializer::from_str(json_str)
    .into_iter::();

// Custom serialization
#[derive(Serialize)]
struct Custom<T> {
    data: T,
    #[serde(serialize_with = "serialize_datetime")]
    timestamp: DateTime<Utc>,
}

Ok(())
}

// Comprehensive error type
#[derive(Debug, thiserror::Error)]
enum AppError {
#[error("IO error: {0}")]
Io(#[from] std::io::Error),

#[error("Parse error: {0}")]
Parse(#[from] std::num::ParseIntError),

#[error("Database error: {0}")]
Database(#[from] sqlx::Error),

#[error("Validation error: {msg}")]
Validation { msg: String, code: u32 },
}

// Error context with anyhow
use anyhow::{Context, Result};

fn read_config() -> Result<Config> {
std::fs::read_to_string("config.json")
    .context("Failed to read config file")?
    .parse()
    .context("Failed to parse config file")
}

// Error handling middleware
impl From<AppError> for HttpResponse {
fn from(error: AppError) -> Self {
    match error {
        AppError::Validation { msg, code } => 
            HttpResponse::BadRequest()
                .json(json!({ "error": msg, "code": code })),
        _ => HttpResponse::InternalServerError()
                .json(json!({ "error": "Internal server error" }))
    }
}
}

// Result combination patterns
fn process_data() -> Result<(), AppError> {
let results: Result, _> = items
    .into_iter()
    .map(process_item)
    .collect();

results?
    .into_iter()
    .try_for_each(validate_item)?;
    
Ok(())
}

// Async streams
use futures::stream::{self, StreamExt};

async fn process_stream() {
stream::iter(0..100)
    .chunks(10)
    .for_each_concurrent(4, |chunk| async move {
        process_chunk(chunk).await
    })
    .await;
}

// Resource pool with deadlock prevention
struct Pool<T> {
resources: Arc<Sempahore>,
items: Arc<Mutex<Vec<T>>>,
}

// Cancellation and timeouts
use tokio::time::{timeout, Duration};

async fn with_timeout<F, T>(
duration: Duration,
future: F
) -> Result<T>
where
F: Future<Output = T>,
{
timeout(duration, future).await?
}

// Backoff and retry
async fn with_retry<F, Fut, T>(
f: F,
max_retries: u32,
) -> Result<T>
where
F: Fn() -> Fut,
Fut: Future<Output = Result<T>>,
{
let mut retries = 0;
let mut delay = Duration::from_millis(100);

loop {
    match f().await {
        Ok(value) => return Ok(value),
        Err(e) if retries < max_retries => {
            retries += 1;
            sleep(delay).await;
            delay *= 2;
        }
        Err(e) => return Err(e),
    }
}
}

// Actor pattern with channels
struct Actor {
receiver: mpsc::Receiver<Message>,
state: ActorState,
}

impl Actor {
async fn run(&mut self) {
    while let Some(msg) = self.receiver
        .recv()
        .await
    {
        self.handle_message(msg).await;
    }
}
}

// Property-based testing with proptest
use proptest::prelude::*;

proptest! {
#[test]
fn test_parse_never_crashes(s: String) {
    let _ = parse_input(&s);
}
}

// Parameterized tests
#[rstest]
#[case(2, 2, 4)]
#[case(3, 3, 9)]
#[case(4, 4, 16)]
fn test_multiply(
#[case] a: i32,
#[case] b: i32,
#[case] expected: i32,
) {
assert_eq!(multiply(a, b), expected);
}

// Mock objects
#[automock]
trait Database {
async fn get_user(&self, id: u64) -> Result<User>;
}

#[tokio::test]
async fn test_with_mock() {
let mut mock = MockDatabase::new();
mock.expect_get_user()
    .returning(|_| Ok(User::default()));
}

// Snapshot testing
#[test]
fn test_snapshot() {
let data = process_complex_data();
insta::assert_yaml_snapshot!(data);
}

// Async test utilities
#[tokio::test]
async fn test_concurrent() {
let (tx, rx) = mpsc::channel(10);

tokio::spawn(async move {
    process_messages(rx).await
});

tx.send(Message::new()).await?;
}

// Integration testing with test containers
#[tokio::test]
async fn test_with_postgres() {
let container = PostgresContainer::new();
let pool = create_connection_pool(
    container.connection_string()
).await?;

// Run tests against real Postgres
}

// Benchmarking
use criterion::{criterion_group, criterion_main, Criterion};

fn benchmark(c: &mut Criterion) {
c.bench_function("process_data", |b| {
    b.iter(|| process_data(black_box(input)))
});
}

// Basic Tokio setup
#[tokio::main]
async fn main() {
// Multi-threaded runtime
let runtime = Runtime::new()
    .worker_threads(4)
    .enable_all()
    .build()
    .unwrap();

// Single-threaded runtime
let runtime = Runtime::new()
    .basic_scheduler()
    .enable_all()
    .build()
    .unwrap();
}

// Task spawning and management
let handle = tokio::spawn(async {
process_data().await
});

// Join multiple tasks
let (result1, result2) = tokio::join!(
async_operation1(),
async_operation2()
);

// Select first completed future
tokio::select! {
result = async_operation1() => {
    println!("Operation 1 completed first");
}
result = async_operation2() => {
    println!("Operation 2 completed first");
}
}

// Time utilities
use tokio::time::{sleep, timeout, Duration};

// Delay execution
sleep(Duration::from_secs(1)).await;

// Add timeout to operation
let result = timeout(
Duration::from_secs(5),
async_operation()
).await??;

// Interval-based execution
let mut interval = tokio::time::interval(
Duration::from_secs(1)
);

loop {
interval.tick().await;
perform_periodic_task().await;
}

// Channels
use tokio::sync::{mpsc, oneshot, broadcast, watch};

// Multi-producer, single-consumer
let (tx, mut rx) = mpsc::channel(32);

// Broadcast channel
let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();

// Watch channel (single producer, multi-consumer)
let (tx, mut rx) = watch::channel("initial value");

// One-shot channel
let (tx, rx) = oneshot::channel();

// Synchronization primitives
use tokio::sync::{Mutex, RwLock, Semaphore};

// Async mutex
let mutex = Arc::new(Mutex::new(0));
{
let mut lock = mutex.lock().await;
*lock += 1;
}

// Async read-write lock
let rwlock = Arc::new(RwLock::new(vec![]));
{
let mut write = rwlock.write().await;
write.push(1);
}

// Semaphore for resource limiting
let semaphore = Arc::new(Semaphore::new(3));
{
let permit = semaphore.acquire().await?;
perform_limited_task().await;
}

// I/O utilities
use tokio::io::{AsyncReadExt, AsyncWriteExt};

// Async file operations
let mut file = tokio::fs::File::create("file.txt").await?;
file.write_all(b"Hello").await?;

// TCP connections
let listener = TcpListener::bind("127.0.0.1:8080").await?;

while let Ok((socket, addr)) = listener.accept().await {
tokio::spawn(async move {
    process_socket(socket).await
});
}

// Vec - Dynamic array
let mut vec: Vec<i32> = Vec::new();
vec.push(1);
vec.extend([2, 3, 4]);
vec.insert(1, 5);
vec.remove(0);
vec.drain(1..3);
vec.retain(|&x| x % 2 == 0);

// Advanced Vec operations
vec.chunks(2)
.filter(|chunk| chunk.len() == 2)
.for_each(|chunk| println!("{:?}", chunk));

vec.windows(2)
.map(|window| window[0] + window[1])
.collect::<Vec<_>>();

// VecDeque - Double-ended queue
let mut deque = VecDeque::new();
deque.push_front(1);
deque.push_back(2);
deque.pop_front();
deque.pop_back();

// LinkedList - Doubly-linked list
let mut list = LinkedList::new();
list.push_back(1);
list.push_front(0);
list.append(&mut other_list);
list.splice(1..3, some_iter);

// HashMap - Key-value store
let mut map = HashMap::new();
map.insert("key", "value");
map.entry("key")
.or_insert("default");
map.entry("key")
.and_modify(|v| *v = "new value")
.or_insert("default");

// Advanced HashMap operations
map.retain(|&k, &mut v| k.len() > 3);
map.get_key_value("key");
map.remove_entry("key");

// HashSet - Unique elements
let mut set = HashSet::new();
set.insert(1);
set.remove(&1);
set.contains(&1);

// Set operations
let union: HashSet<_> = set1.union(&set2).collect();
let intersection = set1.intersection(&set2);
let difference = set1.difference(&set2);
let symmetric_difference = set1.symmetric_difference(&set2);

// BTreeMap - Ordered key-value store
let mut btree = BTreeMap::new();
btree.insert(1, "one");
btree.range(1..3);
btree.first_key_value();
btree.last_key_value();

// BinaryHeap - Priority queue
let mut heap = BinaryHeap::new();
heap.push(1);
heap.pop();
heap.peek();
heap.into_sorted_vec();

// String - UTF-8 encoded text
let mut string = String::from("hello");
string.push_str(" world");
string.replace("hello", "hi");
string.split_whitespace()
  .map(str::to_uppercase)
  .collect::<Vec<_>>();

// Advanced String operations
string.chars().rev().collect::<String>();
string.lines()
  .filter(|line| !line.is_empty())
  .collect::<Vec<_>>();

// Specialized containers
use std::collections::{BTreeSet, HashMap};

// BTreeSet - Ordered unique elements
let mut btree_set = BTreeSet::new();
btree_set.insert(1);
btree_set.range(1..3);

// SmallVec (from smallvec crate) - Stack-first vector
use smallvec::{SmallVec, smallvec};
let mut small_vec: SmallVec<[u8; 4]> = smallvec![1, 2, 3];

// Performance considerations
// Vec: O(1) push/pop at end, O(n) insert/remove
// VecDeque: O(1) push/pop at both ends
// HashMap: O(1) average case operations
// BTreeMap: O(log n) operations, ordered
// LinkedList: O(1) push/pop, O(n) random access
// BinaryHeap: O(log n) push/pop, ordered by priority

// Reading and writing files - basic operations
use std::fs;
use std::io::{self, Read, Write, BufRead, BufReader};

// Read entire file to string - good for small files
fn read_file(path: &str) -> io::Result<String> {
fs::read_to_string(path)
}

// Read file line by line - better for large files
fn process_lines(path: &str) -> io::Result<()> {
let file = File::open(path)?;
let reader = BufReader::new(file);

for line in reader.lines() {
    let line = line?;
    // Process each line here
}
Ok(())
}

// Write data to file
fn save_data(path: &str, data: &str) -> io::Result<()> {
fs::write(path, data)
}

// Append to file
fn append_to_file(path: &str, data: &str) -> io::Result<()> {
let mut file = OpenOptions::new()
    .append(true)
    .create(true)
    .open(path)?;

writeln!(file, "{}", data)
}

// Common file operations
fn file_operations() -> io::Result<()> {
// Check if file exists
if Path::new("file.txt").exists() {
    // Copy file
    fs::copy("file.txt", "backup.txt")?;
    
    // Rename file
    fs::rename("file.txt", "new_name.txt")?;
    
    // Delete file
    fs::remove_file("old_file.txt")?;
}

// Create directory
fs::create_dir_all("nested/dirs")?;

// List directory contents
for entry in fs::read_dir(".")? {
    let entry = entry?;
    println!("{}", entry.path().display());
}

Ok(())
}

// Simple command line app template
use clap::Parser;

#[derive(Parser)]
#[command(name = "myapp")]
#[command(about = "A simple utility program")]
struct Args {
// Required input file
#[arg(short, long)]
input: PathBuf,

// Optional output file
#[arg(short, long)]
output: Option<PathBuf>,

// Flag for verbose output
#[arg(short, long)]
verbose: bool,
}

// Example main function with error handling
fn main() -> Result<(), Box<dyn Error>> {
// Parse command line arguments
let args = Args::parse();

// Read input file
let content = fs::read_to_string(&args.input)
    .with_context(|| format!("Failed to read {}", args.input.display()))?;

// Process the content
let processed = process_content(&content)?;

// Write to output file or stdout
match args.output {
    Some(path) => fs::write(path, processed)?,
    None => println!("{}", processed),
}

Ok(())
}

// Working with environment variables
use std::env;

fn env_operations() {
// Get environment variable
let key = env::var("HOME").unwrap_or_default();

// Set environment variable
env::set_var("MY_VAR", "value");

// Get all environment variables
for (key, value) in env::vars() {
    println!("{}: {}", key, value);
}
}

// Text processing utilities
fn text_processing(text: &str) -> String {
// Split and process lines
text.lines()
    .filter(|line| !line.trim().is_empty())
    .map(|line| line.trim().to_uppercase())
    .collect::<Vec<_>>()
    .join("\n")
}

// Simple logging setup
fn setup_logging() -> Result<(), fern::InitError> {
fern::Dispatch::new()
    .format(|out, message, record| {
        out.finish(format_args!(
            "[{}][{}] {}",
            record.level(),
            record.target(),
            message
        ))
    })
    .level(log::LevelFilter::Info)
    .chain(std::io::stdout())
    .chain(fern::log_file("program.log")?)
    .apply()?;

Ok(())
}

// Configuration file handling
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Config {
api_key: String,
max_retries: u32,
timeout: u64,
}

fn load_config() -> Result<Config, Box<dyn Error>> {
let config_path = get_config_path()?;
let contents = fs::read_to_string(config_path)?;
Ok(toml::from_str(&contents)?)
}

// Progress indication for long operations
use indicatif::{ProgressBar, ProgressStyle};

fn process_with_progress<T>(items: Vec<T>) {
let pb = ProgressBar::new(items.len() as u64);
pb.set_style(ProgressStyle::default_bar()
    .template("[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len}")
    .unwrap());

for item in items {
    // Process item
    pb.inc(1);
}
pb.finish_with_message("done");
}

// Common string manipulations
fn string_operations(text: &str) -> String {
// Remove whitespace
let trimmed = text.trim();

// Split by delimiter
let parts: Vec<&str> = text.split(',').collect();

// Replace text
let replaced = text.replace("old", "new");

// Convert case
let upper = text.to_uppercase();
let lower = text.to_lowercase();

// Find and extract
if let Some(start) = text.find("start") {
    if let Some(end) = text.find("end") {
        return text[start..end].to_string();
    }
}

String::new()
}