Idiomatic Rust
and functional programming features
Go to github.com/alphagergedan/getting-rusty-bootcamp

About me

What is idiomatic coding?

if (input !== null && input !== undefined && input !== "") {
    console.log("Input is valid");
}
if (input) {
    console.log("Input is valid");
}

What is idiomatic Rust?

Today's agenda

Ownership & Borrowing

Ownership & Borrowing

fn greet(user: String) {
    println!("Hello, {}!", user); // `user` goes out of scope
}
fn farewell(user: String) {
    println!("Bye {}!", user);
}
fn main() {
    let user = String::from("Marty Friedman");
    greet(user); // Passes ownership to greet
    farewell(user); // Error: Use of moved value `user`
}

Ownership & Borrowing

fn greet(user: &String) {
    println!("Hello, {}!", user);
}
fn farewell(user: &String) {
    println!("Bye {}!", user);
}
fn main() {
    let user = String::from("Marty Friedman");
    greet(&user); // Immutable borrow
    farewell(&user); // Immutable borrow
}

Ownership & Borrowing

fn main() {
    let user: &str = "Guthrie Govan";
    greet(&user); // Error: Expected reference `&String`
    farewell(&user);
}

Ownership & Borrowing

fn greet(user: &str) {
    println!("Hello, {}!", user);
}
fn farewell(user: &str) {
    println!("Bye {}!", user);
}
fn main() {
    let user: &str = "Guthrie Govan";
    greet(user); farewell(user);

    // This works too!
    let user = String::from("Marty Friedman");
    // Note: Use `.as_ref()` to explicitly convert to `&str`
    // Here: Compiler figures it out!
    greet(&user); farewell(&user);
}

Ownership & Borrowing

Another example

fn print_slice(slice: &[i32]) {
    println!("Slice: {:?}", slice);
}

fn main() {
    let arr: [i32; 4] = [1, 2, 3, 4];
    print_slice(&arr);

    // This works too!
    let vec: Vec<i32> = vec![5, 6, 7, 8];
    // Again, compiler figures out `&Vec<i32>` -> `&[i32]`
    print_slice(&vec);
}

Ownership & Borrowing

let data: Vec<i32> = vec![0, 1, 2, 3, 4];
let slice: &[i32] = &data[1..4]; // &[1,2,3]
let slice: &[i32] = &data[1..=4]; // &[1,2,3,4]

let data = {
    let mut data: Vec<i32> = vec![1, 2, 3];
    data.push(4); // Requires mutation
    data
};

// Here `data` is immutable
let sum: i32 = data.iter().sum(); // sum is 10

Ownership & Borrowing

let s = String::from("hello");
println!("Hello {}", &s); // Borrowing avoids cloning

let name: &str = "Jason Becker";
let mut hello_name = String::from("Hello ");
hello_name.push_str(name);
hello_name.push_str('!');

// Better/easier with `format!`
let hello_name: String = format!("Hello {}!", name);

Enums & Structs

Enums & Structs

enum Direction {
    North, South,
    East, West,
}

fn main() {
    let dir = Direction::North;
    match dir {
        Direction::North => println!("Going North"),
        _ => println!("Not going North")
    }
}

Enums & Structs

Enums can carry data

enum Color {
    RGB(u8, u8, u8),
    RGBA(u8, u8, u8, u8),
}

fn main() {
    let red = Color::RGB(255, 0, 0);

    // Error! Use tuple structs or pattern matching!
    println!("Color: RGB({red.0}, {red.1}, {red.2})");
}

Enums & Structs

Accessing fields of enums

enum Color {
    RGB(u8, u8, u8),
    RGBA(u8, u8, u8, u8),
}
fn main() {
    let red = Color::RGB(255, 0, 0);
    match red {
        Color::RGB(r, g, b) => println!(...),
        Color::RGBA(r, g, b, a) => println!(...),
    }

    // To only match `Color::RGB`
    if let Color::RGB(r, g, b) = red {
        println!("Color: RGB({r}, {g}, {b})");
    }
}

Enums & Structs

Example: bevy game engine (bevy-0.15.0)

enum Color {
    Srgba(Srgba),
    LinearRgba(LinearRgba),
    // [...]
}

struct Srgba {
    red: f32,
    green: f32,
    blue: f32,
    alpha: f32,
}

Enums & Structs

enum AccountState {
    Active { user: String, balance: u32 },
    Suspended { user: String },
}

fn deactivate(accs: &mut AccountState) {
    if let AccountState::Active { user, balance: 0 } = accs {
        // Note: We do not own `user`
        *accs = AccountState::Suspended {
            user: std::mem::take(user)
        };
    }
}

Enums & Structs

The newtype pattern (wrapper around a type)

// Tuple struct
struct Meters(f64); // The newtype pattern

// Type alias
type Meters = f64; // Does not create a custom type

• A (creational) design pattern in Rust
• Used to create new, distinct types with custom behavior (by implementing traits and methods)
• Allows defining custom behavior for the new type without affecting the original type
• Use the newtype idiom instead of type:
• type creates an alias but doesn't enforce type safety (type Meters = f64; is still considered as f64)
• newtype idiom allows custom behavior implementations

Enums & Structs

Use explicit field names in enums and structs if it makes more sense

struct Point { x: f64, y: f64, }

struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

enum Message {
    Quit,
    Shift { x: f64, y: f64 },
    ChangeColor(Color),
    Write(String),
    // [...]
}

Enums & Structs

impl Rectangle {
    fn shift(&mut self, dx: f64, dy: f64) {
        self.top_left.x += dx;
        self.top_left.y += dy;
        self.bottom_right.x += dx;
        self.bottom_right.y += dy;
    }
}

fn main() {
    let top_left = Point { x: 0., y: 1. };
    let bottom_right = Point { x: 1., y: 0. };
    let mut rect = Rectangle { top_left, bottom_right };
    let msg = Message::Shift { x: 1., y: 1. };
    if let Message::Shift { x: dx, y: dy } = msg {
        rect.shift(dx, dy);
    }
}

Enums & Structs

impl Rectangle {
    fn new(top_left: Point, bottom_right: Point) -> Self {
        Self { top_left, bottom_right }
    }
}

fn main() {
    let top_left = Point { x: 0., y: 1. };
    let bottom_right = Point { x: 1., y: 0. };
    let rect = Rectangle::new(top_left, bottom_right);
}

Traits

Traits

trait Area {
    fn area(&self) -> f64;
}

impl Area for Rectangle {
    fn area(&self) -> f64 {
        let width = self.bottom_right.x - self.top_left.x;
        let height = self.top_left.y - self.bottom_right.y;
        width * height
    }
}

// Other structs can implement this trait

Traits

#[derive(Debug, Default, Copy, Clone, PartialEq, PartialOrd)]
struct Point { x: f64, y: f64 }

Traits

impl Default for Rectangle {
    fn default() -> Self {
        Self {
            top_left: Point { x: 0., y: 1. },
            bottom_right: Point { x: 1., y: 0. }
        }
    }
}

Traits

fn main() {
    let rect = Rectangle {
        bottom_right: Point { x: 2., y: 0. },
        ..Default::default()
    };
}

Traits

let readable: &mut dyn std::io::Read = if arg == "-" {
    &mut std::io::stdin() // of `Stdin` type
} else {
    &mut std::fs::File::open(arg)? // of `File` type
};
let mut buffer = String::new();
readable.read_to_string(&mut buffer)?;

Traits

enum Shape {
    Circle { center: Point, radius: f64 },
    Rectangle { top_left: Point, bottom_right: Point }
}
impl Area for Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle { center, radius } => {
                std::f64::consts::PI * radius * radius
            },
            Shape::Rectangle { top_left, bottom_right } => {
                let width = bottom_right.x - top_left.x;
                let height = top_left.y - bottom_right.y;
                width * height
            }
        }
    }
}

Traits

The shape type can be resolved during runtime

struct Rectangle { top_left: Point, bottom_right: Point, }
struct Circle { center: Point, radius: f64, }

impl Area for Rectangle {
    fn area(&self) -> f64 {
        let width = self.bottom_right.x - self.top_left.x;
        let height = self.top_left.y - self.bottom_right.y;
        width * height
    }
}
impl Area for Circle {
    fn area(&self) -> f64 {
        f64::consts::PI * self.radius * self.radius
    }
}

Traits

Conversion traits

let name = String::from("ata");        // From<&str>
let name_slice: &str = name.as_ref();  // AsRef<&str>
let name_bytes: &[u8] = name.as_ref(); // AsRef<&[u8]>
println!("{}", name_slice);   // ata
println!("{:?}", name_bytes); // [97, 116, 97]

• From<T>: Converts from type `T` to the target type `Self`.
• TryFrom<T>: Converts from type `T` to the target type `Self`, but may fail.
  returns a `Result`
• AsRef<T>: Provides a cheap, reference-to-reference conversion from `&Self` to `&T`.
• AsMut<T>: Provides a cheap, mutable reference-to-reference conversion from `&mut Self` to `&mut T`.

From<T> for U implies Into<U> for T ⇒ you should prefer implementing the From trait

Traits

Examples from the standard library

• From<u16> is implemented for u32 because a smaller integer can always be converted to a bigger integer.
• From<u32> is NOT implemented for u16 because the conversion may not be possible if the integer is too big.
• TryFrom<u32> is implemented for u16 and returns an error if the integer is too big to fit in.

Traits

Reminder: Deriving the Debug trait provides printing via {:?}

#[derive(Debug)]
struct Point { x: f64, y: f64 }

fn main() {
    let p = Point { x: 0., y: 1. };
    println!("{:?}", p); // Point { x: 0.0, y: 1.0 }
    println!("{}", p);   // Error: Implement `Display` trait
}

Traits

Implementing Display for Point

impl std::fmt::Display for Point {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>)
        -> std::fmt::Result {
        write!(f, "({},{})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 0., y: 1. };
    println!("{:?}", p); // Point { x: 0.0, y: 1.0 }
    println!("{}", p);   // (0,1)
}

Traits

Overridable trait implementation

trait Area {
    fn area(&self) -> f64 {
        0.
    }
}

struct Point { x: f64, y: f64, }

impl Area for Point {} // Uses the default implementation

Traits

Traits as parameters

fn print_area<T: Area>(shape: &T) {
    let area = shape.area();
    println!("Area: {}", area);
}

fn print_area(shape: &impl Area) {
    let area = shape.area();
    println!("Area: {}", area);
}

Traits

For multiple trait bounds use where clauses

fn display_and_print_areas<T, U>(shape1: &T, shape2: &U)
where
    T: Area + std::fmt::Display,
    U: Area + std::fmt::Display,
{
    let area1 = shape1.area();
    let area2 = shape2.area();
    println!("Shape {} has area {}", shape1, area1);
    println!("Shape {} has area {}", shape2, area2);
}

Error handling

Error handling

In rust we have no undefined, null, exception...

In Rust:

• For values that might be absent:
  

  enum Option<T> {
      None,     // no value is available
      Some(T),  // value is available
  }

• For operations that might fail:
  

  enum Result<T, E> {
      Ok(T),    // operation is successful
      Err(E),   // operation returned an error
  }

Key principle: Avoid panicking in recoverable scenarios; handle errors and none types explicitly.

Error handling

Understanding Option<T>

fn find_user(id: u32) -> Option<String> {
    if id == 1 {
        Some(String::from("Alice"))
    } else {
        None
    }
}

Error handling

Handling Option<T>

• Ignore None:
  

  if let Some(user) = find_user(id) { ... }

• Panic if None:
  

  let user = find_user(id).unwrap();
  // Prefer `.expect` over `.unwrap`
  let user = find_user(id).expect("User must exist");

• Provide a default value if None:
  

  let user = find_user(id)
      .unwrap_or(String::from("Guest"));

Error handling

Optional function arguments

fn foo(a: Option<i32>, b: Option<i32>) {
    if let Some(a) = a {
        println!("a {}", a);
    }
    if let Some(b) = b {
        println!("b {}", b);
    }
}

fn main() {
    foo(None, None);
    foo(Some(1), None); // Some(_) is required
}

Error handling

Optional function arguments with generics and trait bounds

fn foo2<T, U>(a: T, b: U)
where
    T: Into<Option<i32>>,
    U: Into<Option<i32>>,
{
    if let Some(a) = a.into() {
        println!("a {}", a);
    }
    if let Some(b) = b.into() {
        println!("b {}", b);
    }
}
fn main() {
    foo(None, None);
    foo(1, None);   // Some(_) is not explicitly required
}

Error handling

Understanding Error<T, E>

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0. {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

Error handling

Handling Error<T, E> (again using utility functions)

• Ignore Err:
  

  if let Ok(val) = divide(a,b) { ... }

• Panic if Err:
  

  let val = divide(a,b).unwrap();
  // Prefer `.expect` over `.unwrap`
  let val = divide(a,b).expect("Division must succeed");

• Provide a default value if Err:
  

  // Same as `.unwrap_or(0.)` for f64
  let val = divide(a,b).unwrap_or_default();

Error handling

Depending on The error type E in Result<T, E> you can propagate the error

fn read_user(path: &str) -> Result<String, std::io::Error> {
    let f = std::fs::File::open(path);
    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut buffer = String::new();
    match f.read_to_string(&mut buffer) {
        Ok(_) => Ok(buffer),
        Err(e) => Err(e)
    }
}

Error handling

fn read_user(path: &str) -> Result<String, std::io::Error> {
    let mut f = std::fs::File::open(path)?;

    let mut buffer = String::new();
    f.read_to_string(&mut buffer)?;
    Ok(buffer)
}

Error handling

impl std::str::FromStr for Point {
    type Err = std::num::ParseFloatError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let coords: Vec<&str> = s
            .trim_matches(|p| p == '(' || p == ')')
            .split(',')
            .collect();

        let x: f64 = coords[0].parse()?;
        let y: f64 = coords[1].parse()?;

        Ok(Self { x, y })
    }
}

Error handling

fn read_number(path: &str) -> Result<i32, std::io::Error> {
    let mut f = std::fs::File::open(path)?;

    let mut buffer = String::new();
    f.read_to_string(&mut buffer)?;

    let parsed_num = buffer.trim().parse::<i32>()?; // Error
    Ok(parsed_num)
}

Error handling

fn read_number(path: &str) -> Result<i32, String> {
    let mut f = std::fs::File::open(path)
        .map_err(|e| format!("Failed to open file: {}", e))?;

    let mut buffer = String::new();
    f.read_to_string(&mut buffer)
        .map_err(|e| format!("Failed to read file: {}", e))?;

    let parsed_num = buffer.trim().parse::<i32>()
        .map_err(|e| format!("Failed to parse: {}", e))?;
    Ok(parsed_num)
}

Error handling

#[derive(Debug)]
enum FileReadError {
    FileOpen(std::io::Error),
    Parse(std::num::ParseIntError),
}

// To be compatible with the ecosystem
impl std::error::Error for FileReadError { }

Error handling

impl std::fmt::Display for FileReadError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>)
        -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

Error handling

impl From<std::io::Error> for FileReadError {
    fn from(e: std::io::Error) -> Self {
        FileReadError::FileOpen(e)
    }
}

impl From<std::num::ParseIntError> for FileReadError {
    fn from(e: std::num::ParseIntError) -> Self {
        FileReadError::Parse(e)
    }
}

Error handling

fn read_number(path: &str) -> Result<i32, FileReadError> {
    let mut f = std::fs::File::open(path)?;

    let mut buffer = String::new();
    f.read_to_string(&mut buffer)?;

    let parsed_num = buffer.trim().parse()?;
    Ok(parsed_num)
}

Error handling

#[derive(Debug, thiserror::Error)]
enum FileReadError {
    #[error("Failed to open file: {0}")]
    FileError(#[from] std::io::Error),
    #[error("Failed to parse number: {0}")]
    ParseError(#[from] std::num::ParseIntError),
}

Iterators & Closures

Iterators & Closures

Remember for loop in Rust

for x in 0..4 {     // x in {0, 1, 2, 3}
    println!("{}", x);
}

let mut range = 0..4;
loop {
    match range.next() {
        Some(x) => println!("{}", x),
        None => break,
    }
}

Iterators & Closures

Iterators are abstractions for sequentially accessing elements of a collection.

Traits
• Iterator: core trait with the method .next()
• IntoIterator: Enables conversion into an iterator
• ExactSizeIterator: Additional trait to provide .len() information
• DoubleEndedIterator: Enables reverse iteration with .next_back()
Key features
• Laziness: Iterators do nothing until consumed
• Adapters: Allow declarative chain transformations
There are usually three forms of iteration
• .iter(), which iterates over &T
• .iter_mut(), which iterates over &mut T
• .into_iter(), which iterates over T

Iterators & Closures

Implementing an iterator

struct Counter { count: usize }
impl Iterator for Counter {
    type Item = usize;
    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        Some(self.count)
    }
}

let counter = Counter { count: 0 };
let mut it = counter.into_iter();
it.next(); // Some(1)

let counter = Counter { count: 0 };
// Consumes `counter` and calls .next() till None is returned
for c in counter { ... }

Iterators & Closures

Do not use 'C-style' for loop

let nums = vec![1, 2, 3];
for idx in 0..nums.len() {
    println!("{}", nums[idx]); // unnecessary bounds check
}

for num in &nums {
    println!("{}", *num); // no bounds check but still safe
}

for (idx, num) in nums.iter().enumerate() {
    println!("idx {}: {}", idx, num);
}

Iterators & Closures

let one_to_hundred: Vec<u8> = (1..=100).collect();

let nums: Vec<i32> = vec![1, 2, 3, 4];
let even: Option<&i32> = nums
    .iter()
    .find(|&x| x % 2 == 0); // 2

let sum = nums
    .iter()
    .fold(0, |acc, &x| acc + x); // 15

Iterators & Closures

let squares: Vec<i32> = nums.iter().map(|&x| x*x).collect();

let first_three: Vec<&i32> = nums.iter().take(3).collect();

let evens: Vec<&i32> = nums
    .iter()
    .filter(|&x| x % 2 == 0)
    .collect();

Iterators & Closures

let add: &dyn Fn(&i32) -> i32 = &|&x| x + outer_var;

let a = 1;
nums
    .iter()
    .for_each(|&x| println!("{}", x + a));

Iterators & Closures

// impl Fn
let a = 1;
let add_a = |x: i32| x + a; // add_a(x)

// FnMut
let mut a: u32 = 1;
let mut inc_a = || a += 1; // inc_a()

// FnOnce
let name = String::from("Aylin");
let say_hello = || {
    let s = name;
    println!("Hello, {}", s);
}; // say_hello();

Iterators & Closures

The move keyword

let data = vec![1, 2, 3];
let closure = move || println!("captured {data:?} by value");

// Error
println!("{:?}", data); // data is not available,
                        // it is owned by the closure

Iterators & Closures

fn apply_closure<F>(f: F, x: i32) -> i32
where
    F: Fn(i32) -> i32,
    {
        f(x)
    }

let double = |x| x * 2;
println!("{}", apply_closure(double, 5)); // 10

Iterators & Closures

fn create_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
    move |x| x * factor
}

let multiply_by_3 = create_multiplier(3);
println!("{}", multiply_by_3(5)); // 15

Wrap-Up

• Idiomatic Rust: Write concise, ecosystem-friendly code by embracing ownership, borrowing, and community conventions.
• Ownership & Borrowing: Master Rust's memory safety through ownership rules, borrowing practices, and reference validity.
• Enums & Structs: Utilize enums for flexible variants and pattern matching, and design structs for data organization and behavior.
• Traits: Leverage traits to define shared behavior, enable polymorphism, and derive common functionality like Debug and Clone.
• Error Handling: Handle errors with Option and Result, propagate them with ?, and simplify with custom error types or libraries like thiserror.
• Functional Features: Utilize iterators and closures for clean, efficient, and expressive logic, embracing their laziness and declarative transformation power.

Resources

• https://doc.rust-lang.org/book/
• https://rust-unofficial.github.io/patterns/idioms/index.html
• https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/iterators.html
• https://edgl.dev/blog/wrapping-errors-in-rust/
• https://hoverbear.org/blog/optional-arguments/
• https://doc.rust-lang.org/std/iter/index.html
• https://fettblog.eu/slides/idiomatic-rust/

Next steps

• Async
• Testing (by me)
• Advanced features
• Decentralized programming
• Blockchain development
• Project, review and next steps