Rust in a Nutshell

rust_nutshell.md

Rust in a Nutshell

Table of Contents

• Rust: The Language
  • Borrow Checker
  • Macros
  • Parallelism & Concurrency
  • Example
  • Dependency injection
  • Functional Programming in Rust
  • Low-level Programming in Rust
  • Cross-compilation
  • FFI with C
  • Project Structure
• Ecosystem
  • Rustup
  • IDE support
  • Documentation
  • Libraries
  • How to pick a library
  • Community
• Good practices
• Learning Rust
  • More resources

Rust: The Language

Features:

• Compiled to machine code
• Strong, static typing
• Imperative, with functional aspects
• Can do both high-level and low-level programming
• No garbage collection or runtime
• Control allocation
• Safe (e.g. no null pointers, correct concurrency...)
• Cross-compilation (WebAssembly!)
• Works with traditional tools (e.g. perf, gdb, valgrind...)
• Modern type system
• Long-term viability: Mozilla, Dropbox, CloudFlare, Microsoft, Google, Amazon, Facebook, Atlassian, npm

Drawbacks:

• Learning curve: borrow checker
• Ecosystem: still growing
• Compile times are great compared to Haskell, but still slow compared to Go, C.
• Vendor support (e.g. CUDA sdk, NVIDIA sdk), no C++ integration.
• Windows ? Linux and MacOS mainly

Borrow Checker

• Borrowing
• Ownership
• Dangling pointers

Macros

• Declarative macros e.g. vec!
• Procedural macros e.g. #[derive(MyTrait)]
• Example

Resources:

• The Little Book of Rust Macros
• Procedural macros: exercises

Parallelism & Concurrency

• Task parallelism
• Data parallelism
• Async

Example

Transaction Engine

Dependency injection

A common practice is to use traits and parametric structs.

Use mockall for testing.

• config-rs`
  • Example
  • Global

Functional Programming in Rust

• Algebraic Data Types + patterns
• Efficient Generics (monomorphization)
• Higher-order functions
• Iterators
• Option(Maybe) and Result(Either)
• No Monads, but we have ?
• sequence and traverse

Not recommended:

• frunk: HList, Generic, Semigroup, Monoid ...
• fp-core.rs

Low-level Programming in Rust

Rust is sold (or was sold) as an embedded programming language.

FFI with C

Lots of tools:

• libc
• cbindgen: c headers from Rust
• bindgen: generates Rust extern functions from c headers

See example

Cross-compilation

Rust can cross-compile to a big number of platforms: x86, arm, mips, powerpc, risc-v... with just cargo build --target=x86_64-apple-darwin

Project Structure

• Recommended package layout
• Explore nom

Ecosystem

• rustc
• cargo
• rustfmt
• clippy

Rustup

rustup

• Any toolchain(channel + version), any target(cross-compilation), any component(clippy, lsp)!
• rustup run stable rustc --version (or rustc +stable --version)
• rustup default nightly
• rustup component add rust-docs

IDE support

• rust-analyzer: rustup +nightly component add rust-analyzer-preview
• Vscode, vim/neovim, emacs, etc.

Documentation

• std
• crates.io e.g. https://crates.io/crates/tokio
• Docs.rs e.g. https://docs.rs/tokio/latest/tokio/
• rustodc

Libraries

• https://lib.rs : I don't find it super useful
• https://github.com/rust-unofficial/awesome-rust
• https://github.com/vaaaaanquish/Awesome-Rust-MachineLearning
• https://cryptography.rs/

How to pick a library

Example: picking an HTTP Server

Candidates:

• https://github.com/SergioBenitez/Rocket (18k stars)
• https://github.com/actix/actix-web (15k stars)
• https://github.com/seanmonstar/warp (7k stars)
• https://github.com/tokio-rs/axum (6k stars)

Community

• https://users.rust-lang.org
• https://www.reddit.com/r/rust/
• https://discord.com/invite/rust-lang

Good practices

• Rust API Guidelines
• Rust Desing Patterns

Learning Rust

Start with The Rust Book and see the other resources below.

More resources

• Rust by example
• The Rust Performance Book
• The Rustonomicon
• The Embedded Rust Book
• Asynchronous Programming in Rust
• The Rust Reference
• Rust Language Cheat Sheet <3