home > research > rust (2026-04-19)

Rust Programming Syntax and Concepts: A Comprehensive Example

Rust Programming Syntax and Concepts: A Comprehensive Example

Table of Contents

Background

Why Rust

Rust is a systems programming language that focuses on three key guarantees:

  • Memory Safety: Rust eliminates entire classes of bugs at compile time through its ownership system, preventing null pointer dereferences, buffer overflows, and data races without requiring a garbage collector.
  • Performance: Rust provides zero-cost abstractions and compiles to native code, offering performance comparable to C and C++ while maintaining high-level ergonomics.
  • Concurrency: The ownership and type system enables fearless concurrency, where the compiler prevents data races and ensures thread safety at compile time.

Rust in 2024-2025 Ecosystem

The Rust ecosystem has matured significantly:

  • Industry Adoption: Major companies (Microsoft, Google, Amazon, Meta) are using Rust for critical infrastructure. Linux kernel now supports Rust modules.
  • Tooling: The cargo package manager and build system provides dependency management, testing, documentation, and benchmarking out of the box.
  • Community: Over 100,000 crates (packages) on crates.io, covering everything from web frameworks to embedded systems.
  • Async Runtime: Mature async/await support with frameworks like Tokio and async-std enabling high-performance concurrent applications.
  • WebAssembly: First-class support for compiling to WASM, making Rust a popular choice for high-performance web applications.

Example

  use std::io;

  fn main() {
      // example
      println!("Guess the number!");

      println!("Please input your guess.");

      let mut guess = String::new();

      io::stdin().read_line(&mut guess)
          .expect("Failed to read line");

      println!("You guessed: {}", guess);
      // bindings
      let (x, y) = (1, 2);
      // mutability
      let mut z = 5;
      z = 10;

       {
          let y: i32 = 3;
          println!("The value of x is {} and value of y is {}", x, y);
       }
      // functions
      fn print_sum(x, y) {
          println!("sum is: {}", x + y);
      }
      // loops
      while !done {
          x += x - 3;

          println!("{}", x);

          if x % 5 == 0 {
              done = true;
          }
      }
      // borrowing
      fn foo(v1: &Vec<i32>, v2: &Vec<i32>) -> i32 {
          // do stuff with v1 and v2

          // return the answer
          42
      }

      let v1 = vec![1, 2, 3];
      let v2 = vec![1, 2, 3];
      let answer = foo(&v1, &v2);
      // node interop
      fn fibonacci(x: i32) -> i32 {
          if x <= 2 {
              return 1;
          } else {
              return fibonacci(x - 1) + fibonacci(x - 2);
          }
      }
  }

Syntax

Concepts

Ownership and Borrowing

Rust's ownership system is its most distinctive feature:

  • Ownership Rules:
    1. Each value has a single owner
    2. When the owner goes out of scope, the value is dropped
    3. Values can be moved or borrowed
  • Borrowing: References allow you to refer to values without taking ownership
    • Immutable references (&T): Multiple allowed simultaneously
    • Mutable references (&mut T): Only one allowed at a time
fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);  // Borrowing
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}  // s goes out of scope but doesn't drop the String

Error Handling

Rust uses Result and Option types for explicit error handling:

  • Result<T, E>: For operations that can fail
    • Ok(T): Success case containing value
    • Err(E): Error case containing error
  • Option<T>: For values that might be absent
    • Some(T): Contains a value
    • None: No value present
use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;  // ? operator propagates errors
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn find_user(id: u32) -> Option<User> {
    if id == 1 {
        Some(User { name: "Alice".to_string() })
    } else {
        None
    }
}

Pattern Matching

Pattern matching provides exhaustive case analysis: 

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Quitting"),
        Message::Move { x, y } => println!("Moving to ({}, {})", x, y),
        Message::Write(text) => println!("Text: {}", text),
        Message::ChangeColor(r, g, b) => println!("RGB({}, {}, {})", r, g, b),
    }
}

// if let for single pattern
if let Some(value) = optional_value {
    println!("Got: {}", value);
}

Traits and Generics

Traits define shared behavior, similar to interfaces: 

trait Summary {
    fn summarize(&self) -> String;
}

struct Article {
    headline: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}", self.headline, self.content)
    }
}

// Generic function with trait bounds
fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

// Multiple trait bounds
fn compare<T: Summary + Display>(a: &T, b: &T) { }

Cargo and Dependencies

Cargo is Rust's build system and package manager:

  • Creating a project: cargo new ~project_name~
  • Building: cargo build (debug) or cargo build --release
  • Running: cargo run
  • Testing: cargo test
  • Documentation: cargo doc --open

Example Cargo.toml: 

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.35", features = ["full"] }
reqwest = "0.11"

[dev-dependencies]
criterion = "0.5"

Additional Concepts

  • Mutability: Variables are immutable by default; use mut keyword for mutability
  • Types:
    • Primitives: i32, u64, f64, bool, char
    • Structs: Custom data types with named fields
    • Enums: Types that can be one of several variants
  • Scope:
    • Closure: Anonymous functions that can capture environment
    • Shadowing: Redeclaring variables with the same name
  • Pattern matching: Exhaustive matching on enum variants and other types
  • Package management: Cargo handles dependencies, building, testing
  • Building: Compile-time guarantees ensure runtime safety
  • Deployment: Single binary output, no runtime dependencies

2026 Review

This section surveys the state of Rust as of early 2026, covering the 2024 edition release, recent compiler improvements, the async ecosystem, ML tooling, and WebAssembly.

Compilation Pipeline

Rust source passes through several intermediate representations before reaching machine code. Understanding these stages helps when reading compiler diagnostics or using tools like cargo-expand.

diagram-rust-pipeline.png

HIR (High-level IR) is where type inference and name resolution happen. MIR (Mid-level IR) is where the borrow checker runs and where many optimizations such as inlining and constant propagation occur before handing off to LLVM.

Rust Edition 2024

Rust Edition 2024 shipped in late 2024 as part of Rust 1.85. Editions are backwards-compatible opt-ins: existing crates continue to compile unchanged, and a crate can depend on edition-2024 crates without migrating itself.

Key stabilizations in Edition 2024:

  • gen blocks: Coroutine-style generators that produce values with yield. A gen {} block implements Iterator, eliminating the need for manual state machines in many iterator adapters.
  • Async closures (async ||): Closures that return futures and capture their environment correctly across await points. Previously, async move || had subtle lifetime issues; the edition fixes the capture semantics so the closure can be used directly with higher-order async APIs.
  • ! type stabilization: The never type ! is now stable as a first-class type. Functions that always panic or loop forever can declare -> ! and the type system reasons about it correctly. This enables cleaner exhaustive match arms and removes several workarounds.
  • RPIT lifetime captures (Return-Position Impl Trait): Edition 2024 changes the default so that impl Trait in return position captures all in-scope lifetime parameters, not just those mentioned in the bound. This is a soundness fix; the old behaviour required explicit + '_ annotations to express the same thing.

Migration is automated: cargo fix --edition handles the vast majority of mechanical changes.

Rust 1.83 to 1.87 Highlights

Rust ships on a six-week release cadence. The 1.83–1.87 window (late 2025 through early 2026) consolidated several long-awaited features:

  • 1.83: const functions can now call a wider set of operations including raw pointer creation and certain floating-point operations. This unblocks const-generic work in libraries like nalgebra and ndarray.
  • 1.84: Cargo's dependency resolver (version 3) became default, producing more reproducible lock files and better diagnostics when version requirements conflict.
  • 1.85: Edition 2024 released. async fn in traits (AFIT) now works without the async-trait proc-macro for the common cases; the proc-macro remains useful for object-safe dynamic dispatch.
  • 1.86: Experimental support for the arm64e (pointer authentication) target on Apple Silicon. The standard library gained several HashMap and BTreeMap entry API improvements for ergonomic in-place mutation.
  • 1.87: Stabilized std::sync::LazyLock (replacing the popular once_cell crate pattern) and improved std::fmt performance for large format strings.

Async Ecosystem

The async story in Rust has converged considerably since 2023:

  • Tokio 1.x: Stable and widely deployed. The 1.x series has maintained API compatibility since 2021. Tokio's tokio-util, tokio-stream, and tower middleware layer form the de-facto standard for network services. No major 2.0 break is planned; the team focuses on internal improvements (io-uring support via tokio-uring) as an opt-in.
  • Async traits: Stable since Rust 1.75 without proc-macros for non-object-safe traits. The remaining gap is object-safe async traits (dyn Trait with async fn); this requires dynosaur or similar workarounds in 2026, with stabilization still in progress.
  • Structured concurrency: The async-std project is in maintenance mode. Most new async code targets Tokio. Libraries like futures-concurrency provide join/race combinators with structured task lifetimes.
  • Runtime agnosticism: Libraries such as hyper, rustls, reqwest (via hyper backend), and sqlx work across runtimes through the futures trait abstractions, though Tokio-specific integrations remain most common.

Rust in AI and Machine Learning

Rust has established itself as a serious option for ML inference and training infrastructure:

  • burn: A deep learning framework with device-agnostic backends (CPU, CUDA via WGPU, Metal, Vulkan). Supports model training and inference, with an eager and a graph mode. Sees active use for on-device inference where memory safety and deterministic performance matter.
  • candle: Hugging Face's minimalist ML framework. Designed for inference of transformer models without Python overhead. Candle runs LLAMA, Mistral, Whisper, and similar architectures. The API intentionally mirrors PyTorch tensors for familiarity.
  • ort: Safe Rust bindings for ONNX Runtime. Most production ML pipelines export to ONNX; ort lets Rust services run those models with hardware acceleration (CUDA, CoreML, DirectML) without leaving the Rust ecosystem.

The shared appeal: predictable latency, no GC pauses, and easy embedding in existing Rust services. The main gap remains training at scale, where PyTorch/JAX ecosystems dominate due to tooling maturity.

Rust for WebAssembly

The WebAssembly story has moved well beyond the original wasm-bindgen + browser use case:

  • Component Model: The WASM Component Model defines a type system (interface types) and linking semantics for composing WASM modules from different languages. Rust's wit-bindgen generates Rust bindings from .wit interface definition files. Components can be composed without a host runtime mediating every call.
  • WASI Preview 2: The WebAssembly System Interface Preview 2 (finalized 2024) replaced the POSIX-inspired Preview 1 with a capability-based design built on the Component Model. Rust targets wasm32-wasip2 for this. Key additions: sockets (wasi:sockets), HTTP (wasi:http), key-value store, and a consistent wasi:cli surface.
  • Wasmtime and Spin: Wasmtime is the reference WASI runtime (Bytecode Alliance). Fermyon's Spin framework uses Wasmtime to run Rust and other language components as serverless-style HTTP handlers. Spin 2.x is in production use for edge deployments.
  • Embedded WASM: Crates like wasmi (interpreter) and wasm3 bindings enable running WASM on microcontrollers, using Rust as both the runtime host and the compiled guest.

Code Examples

Async HTTP client with error handling

use std::time::Duration;

// Requires: tokio = { version = "1", features = ["full"] }
//           reqwest = { version = "0.12", features = ["json"] }
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(10))
        .user_agent("rust-example/1.0")
        .build()?;

    let url = "https://httpbin.org/get";
    let response = client.get(url).send().await?;

    if response.status().is_success() {
        let body: serde_json::Value = response.json().await?;
        println!("{}", serde_json::to_string_pretty(&body)?);
    } else {
        eprintln!("Request failed: {}", response.status());
    }

    Ok(())
}

Iterator adaptors and ownership patterns

fn word_frequencies(text: &str) -> std::collections::HashMap<&str, usize> {
    let mut counts = std::collections::HashMap::new();
    for word in text.split_whitespace() {
        *counts.entry(word).or_insert(0) += 1;
    }
    counts
}

// Dereferences the HashMap iterator's double-refs so callers get (&str, usize) directly.
fn top_words(counts: &std::collections::HashMap<&str, usize>, n: usize) -> Vec<(&str, usize)> {
    let mut pairs: Vec<_> = counts.iter().map(|(&word, &count)| (word, count)).collect();
    pairs.sort_by(|a, b| b.1.cmp(&a.1));
    pairs.into_iter().take(n).collect()
}

fn main() {
    let text = "the quick brown fox jumps over the lazy dog the fox";
    let counts = word_frequencies(text);
    let top = top_words(&counts, 3);

    println!("Top words:");
    for (word, count) in top {
        println!("  {}: {}", word, count);
    }

    // filter and map are lazy; collect drives execution and allocates the final Vec
    let doubled_evens: Vec<i32> = (1..=10)
        .filter(|n| n % 2 == 0)
        .map(|n| n * 2)
        .collect();

    println!("Doubled evens: {:?}", doubled_evens);
}

Trait objects and dynamic dispatch

trait Renderer {
    fn render(&self, content: &str) -> String;
}

struct HtmlRenderer;
struct MarkdownRenderer;

impl Renderer for HtmlRenderer {
    fn render(&self, content: &str) -> String {
        format!("<p>{}</p>", content)
    }
}

impl Renderer for MarkdownRenderer {
    fn render(&self, content: &str) -> String {
        format!("_{}_", content)
    }
}

// Picks a concrete renderer at runtime; the caller gets back a trait object.
fn make_renderer(use_html: bool) -> Box<dyn Renderer> {
    if use_html {
        Box::new(HtmlRenderer)
    } else {
        Box::new(MarkdownRenderer)
    }
}

fn main() {
    let renderers: Vec<Box<dyn Renderer>> = vec![
        make_renderer(true),
        make_renderer(false),
    ];

    let content = "hello world";
    for renderer in &renderers {
        println!("{}", renderer.render(content));
    }
}

Resources for Learning

Official Resources

Advanced Resources

Practice and Community

Specialized Topics

Author: Jason Walsh

j@wal.sh

Last Updated: 2026-04-19 08:30:00

build: 2026-04-19 19:44 | sha: dc5a7f5