CodeBlanks Logo Icon CodeBlanks
Login Register

Variants

Construct and use enum variants.

Working with variants

Enum values are passed to functions, returned, and taken apart with match. match checks at compile time that every variant is handled:

fn ters(y: Yon) -> Yon {
    match y {
        Yon::Kuzey => Yon::Guney,
        Yon::Guney => Yon::Kuzey,
        Yon::Dogu => Yon::Bati,
        Yon::Bati => Yon::Dogu,
    }
}

If you add a new variant to the enum, every match that doesn't handle it fails to compile, so no case is forgotten.

Shortening with use, and methods

Methods are added to enums with impl too. To reduce long names, the variants can be brought into scope:

impl Yon {
    fn yatay_mi(&self) -> bool {
        use Yon::*;
        matches!(self, Dogu | Bati)
    }
}

println!("{}", Yon::Dogu.yatay_mi());   // true

The matches! macro returns, as a bool, whether a value fits a pattern.

Practice Opposite direction

Write fn ters(y: Yon) -> Yon for the Yon enum with match. Print the results of ters(Yon::Kuzey) and ters(Yon::Dogu) with {:?}, separated by a space.

Starter code

main.rs
#[derive(Debug)]
enum Yon {
    Kuzey,
    Guney,
    Dogu,
    Bati,
}

fn main() {
    // buraya yaz
}

Sample solution

main.rs
#[derive(Debug)]
enum Yon {
    Kuzey,
    Guney,
    Dogu,
    Bati,
}

fn ters(y: Yon) -> Yon {
    match y {
        Yon::Kuzey => Yon::Guney,
        Yon::Guney => Yon::Kuzey,
        Yon::Dogu => Yon::Bati,
        Yon::Bati => Yon::Dogu,
    }
}

fn main() {
    println!("{:?} {:?}", ters(Yon::Kuzey), ters(Yon::Dogu));
}

Expected output

Guney Bati

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What is needed to write <code>Yon::Kuzey == Yon::Kuzey</code>?

  • #[derive(PartialEq)] Correct answer
  • #[derive(Debug)]
  • Nothing
  • impl Yon

Explanation: The == operator needs the PartialEq trait; derive generates it automatically.

2 Pattern check

Question 
let y = Yon::Bati;
let yatay = ____(y, Yon::Dogu | Yon::Bati);
Answer 
let y = Yon::Bati;
let yatay = matches!(y, Yon::Dogu | Yon::Bati);

Explanation: The matches! macro returns true if the pattern fits.

3 Syntax and role

Term Meaning
match y { .. } Branching by variant
matches!(y, ..) bool pattern test
use Yon::* Brings variants into scope
#[derive(PartialEq)] == support

All lessons in Beginner

1 Rust basics

  1. What is Rust?
  2. Project with Cargo
  3. Your first program
  4. println! and formatting
  5. Comments
  6. Summary - Rust basics

2 Variables

  1. Variables with let
  2. Mutability with mut
  3. Constants with const
  4. Static variables
  5. Shadowing
  6. Summary - Variables

3 Data types

  1. Integers
  2. Floating point
  3. Bool and char
  4. Tuple
  5. Array
  6. Summary - Data types

4 Strings

  1. &str vs String
  2. Creating a String
  3. Concatenating strings
  4. format! macro
  5. String length
  6. Summary - Strings

5 Project: Calculator

  1. Project skeleton
  2. Reading input
  3. Computing
  4. Error handling
  5. Loop and exit

6 Functions

  1. Defining with fn
  2. Parameters
  3. Return value
  4. Expressions and statements
  5. Early return
  6. Summary - Functions

7 Control flow

  1. if-else
  2. match basics
  3. loop
  4. while loop
  5. for loop
  6. Summary - Control flow

8 Ownership

  1. What is ownership?
  2. Move semantics
  3. Copy trait
  4. Functions and ownership
  5. Return and ownership
  6. Summary - Ownership

9 Borrowing

  1. References
  2. Mutable reference
  3. Borrowing rules
  4. Dangling reference
  5. References and functions
  6. Summary - Borrowing

10 Slices

  1. String slices
  2. Slice syntax
  3. Array slices
  4. Slices and functions
  5. Range types
  6. Summary - Slices

11 Project: Guessing game

  1. Game skeleton
  2. Reading input
  3. Comparing numbers
  4. Random number
  5. Loop and exit

12 Structs

  1. Struct definition
  2. Creating an instance
  3. Tuple struct
  4. Unit-like struct
  5. Field update
  6. Summary - Structs

13 Methods

  1. impl block
  2. self parameter
  3. &mut self
  4. Associated functions
  5. Multiple impl blocks
  6. Summary - Methods

14 Enums

  1. Enum definition
  2. Variants
  3. Variants with data
  4. Option<T>
  5. Option instead of null
  6. Summary - Enums

15 Pattern matching

  1. match patterns
  2. Value binding
  3. if let
  4. while let
  5. _ wildcard
  6. Summary - Pattern matching

16 Project: To-do CLI

  1. Task model
  2. Adding
  3. Listing
  4. Marking done
  5. Reading commands

17 Vectors

  1. Vec<T>
  2. Push and pop
  3. Index and get
  4. Looping a vector
  5. with_capacity
  6. Summary - Vectors

18 Advanced strings

  1. String and &str conversion
  2. chars and bytes
  3. Slicing strings
  4. contains and replace
  5. split and join
  6. Summary - Advanced strings

19 Error handling

  1. Result<T, E>
  2. panic!
  3. ? operator
  4. match and Result
  5. unwrap and expect
  6. Summary - Error handling

20 Beginner final

  1. Vowel counter
  2. Average calculator
  3. Bank account
  4. Temperature converter