CodeBlanks Logo Icon CodeBlanks
Login Register

Variants with data

Define enum variants that carry data.

Variants with data

The real power of Rust enums is that each variant can carry different data:

enum Mesaj {
    Cik,                       // no data
    Tasi { x: i32, y: i32 },   // struct form
    Yaz(String),               // tuple form
    Renk(u8, u8, u8),
}

let m = Mesaj::Tasi { x: 3, y: -1 };

Had we written four separate structs instead, gathering them into one type and passing them to the same function would be hard. The enum unites them all in one type.

Unpacking the data

In match arms the variant's data is bound to variables:

fn anlat(m: &Mesaj) -> String {
    match m {
        Mesaj::Cik => String::from("çıkış"),
        Mesaj::Tasi { x, y } => format!("taşı {x},{y}"),
        Mesaj::Yaz(metin) => format!("yaz: {metin}"),
        Mesaj::Renk(r, g, b) => format!("renk {r}/{g}/{b}"),
    }
}

When matching on &Mesaj, the bound variables are references too; ownership doesn't move.

Practice Describe the messages

Write the Mesaj enum above and the function fn anlat(m: &Mesaj) -> String. Loop over a vector containing Cik, Tasi { x: 3, y: -1 }, Yaz("selam") and Renk(0, 128, 255), and print each on its own line.

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

main.rs
enum Mesaj {
    Cik,
    Tasi { x: i32, y: i32 },
    Yaz(String),
    Renk(u8, u8, u8),
}

fn anlat(m: &Mesaj) -> String {
    match m {
        Mesaj::Cik => String::from("çıkış"),
        Mesaj::Tasi { x, y } => format!("taşı {x},{y}"),
        Mesaj::Yaz(metin) => format!("yaz: {metin}"),
        Mesaj::Renk(r, g, b) => format!("renk {r}/{g}/{b}"),
    }
}

fn main() {
    let mesajlar = vec![
        Mesaj::Cik,
        Mesaj::Tasi { x: 3, y: -1 },
        Mesaj::Yaz(String::from("selam")),
        Mesaj::Renk(0, 128, 255),
    ];
    for m in &mesajlar {
        println!("{}", anlat(m));
    }
}

Expected output

çıkış
taşı 3,-1
yaz: selam
renk 0/128/255

Questions and answers

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

1 How do you reach the text inside <code>Mesaj::Yaz(String::from("a"))</code>?

  • With m.0
  • With m.Yaz
  • With as String
  • By pattern matching with match or if let Correct answer

Explanation: Variant data is only safely unpacked by pattern matching; the compiler needs to know the variant really is Yaz.

2 Struct variant

Question 
let m = Mesaj::Tasi ____;
Answer 
let m = Mesaj::Tasi { x: 3, y: -1 };

Explanation: A struct-form variant is created with braces and field names.

3 Variant and form

Term Meaning
Cik No data
Tasi { x, y } Struct form
Yaz(String) Tuple form, one field
Renk(u8, u8, u8) Tuple form, three fields

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