Match statement

As explained in Refactoring to Rust

A match expression is Rust's pattern-matching control-flow expression that selects and evaluates an arm based on a value's structure or variant.

enum FizzBuzzValue {
  Fizz,
  Buzz,
  FizzBuzz,
  NotDivisible,
}

fn main() {
  for i in 1..101 {
    print_fizzbuzz(i);
  }
}

fn print_fizzbuzz(x: i32) {
  match fizzbuzz(x) {
    FizzBuzzValue::FizzBuzz => {  #1
      println!("FizzBuzz");
    }
    FizzBuzzValue::Fizz => {
      println!("Fizz");
    }
    FizzBuzzValue::Buzz => {
      println!("Buzz");
    }
    FizzBuzzValue::NotDivisible => {
      println!("{}", x);
    }
  }
}

fn fizzbuzz(x: i32) -> FizzBuzzValue {
  if x % 3 == 0 && x % 5 == 0 {
    FizzBuzzValue::FizzBuzz
  } else if x % 3 == 0 {
    FizzBuzzValue::Fizz
  } else if x % 5 == 0 {
    FizzBuzzValue::Buzz
  } else {
    FizzBuzzValue::NotDivisible
  }
}

enum FizzBuzzValue {
  Fizz,
  Buzz,
  FizzBuzz,
  NotDivisible(i32),  #1
}

fn main() {
  for i in 1..101 {
    print_fizzbuzz(i);
  }
}

fn print_fizzbuzz(x: i32) {
  match fizzbuzz(x) {
    FizzBuzzValue::FizzBuzz => {
      println!("FizzBuzz");
    }
    FizzBuzzValue::Fizz => {
      println!("Fizz");
    }
    FizzBuzzValue::Buzz => {
      println!("Buzz");
    }
    FizzBuzzValue::NotDivisible(num) => {  #2
      println!("{}", num);
    }
  }
}

fn fizzbuzz(x: i32) -> FizzBuzzValue {
  if x % 3 == 0 && x % 5 == 0 {
    FizzBuzzValue::FizzBuzz
  } else if x % 3 == 0 {
    FizzBuzzValue::Fizz
  } else if x % 5 == 0 {
    FizzBuzzValue::Buzz
  } else {
    FizzBuzzValue::NotDivisible(x)  #3
  }
}

How Refactoring to Rust covers it

How deep it goes

Explains enum-arm selection, payload binding, and match as a value that can return early on Err.

Examples

Uses FizzBuzz variants, including a data-carrying NotDivisible variant, and matches Result with an early error return.

What you can do after

Apply it via Rust to dispatch enum variants, bind variant data, and handle Result errors with explicit early returns.

How it connects

Connects enum variants and Result error handling, and compares match with switch statements.

liveBookmanning.com

Read Refactoring to Rust on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Rust Servers, Services, and AppsA match statement is a Rust control-flow construct that selects behavior by matching a value against patterns.

Compare how 2 books explain match statement →

Related concepts

• pattern matchingimplements · Pattern matching is the process of comparing data or values with specified or learned patterns to identify correspondence, conformity, or a matching case.
• graph patternuses · A graph pattern is a declarative representation of nodes, relationships, and property constraints used to describe graph structures to match.
• case statementequivalent to · A case or switch construct is a conditional control-flow construct that selects a branch or result from alternatives by matching a value or testing conditions.
• Cypherpart of · Cypher is a declarative graph query language for expressing patterns and retrieving, creating, or modifying property-graph data.
• result typeuses · A type that represents an operation’s outcome as either a successful value or a failure value.
• enumuses · An enum is a type or language construct whose values are selected from a finite set of named alternatives, which may carry associated data.

This explainer was generated by Manning's knowledge graph from the text of Refactoring to Rust. The section links point to the parts of the book it draws on.