Rust conditionals: Difference between revisions

From wikinotes
Line 20: Line 20:
</blockquote><!-- Ternary operator -->
</blockquote><!-- Ternary operator -->


= Pattern Matching =
= match =
<blockquote>
== Basics ==
<blockquote>
<blockquote>
Like a switch statement,<br>
Like a switch statement,<br>
Line 45: Line 47:
}
}
</syntaxhighlight>
</syntaxhighlight>
</blockquote><!-- Basics -->


== Matching Enums ==
<blockquote>
When matching a parametrized enum, you can access the tuple/struct/value that is bound to it
When matching a parametrized enum, you can access the tuple/struct/value that is bound to it
<syntaxhighlight lang="rust">
<syntaxhighlight lang="rust">
Line 56: Line 61:
let pet = Pet::Lizard(5);
let pet = Pet::Lizard(5);
match pet {
match pet {
     Cat(name, age) => { format!("cat, name={}, age={}", name, age) },
     Pet::Cat(name, age) => { format!("cat, name={}, age={}", name, age) },
     Dog(dog)      => { format!("dog, name={dog.name}, age={dog.age}") },
     Pet::Dog(dog)      => { format!("dog, name={dog.name}, age={dog.age}") },
     Lizard(age)    => { format!("lizard, age={}", age) }
     Pet::Lizard(age)    => { format!("lizard, age={}", age) }
}
</syntaxhighlight>
</blockquote><!-- Matching Enums -->
 
== Matching Option ==
<blockquote>
Option is just an enum, generally if you don't have a specific behaviour for <code>None</code>,<br>
you return a new <code>None</code> in that branch.<br>
However this an opportunity to fail if it is an appropriate location for it.
 
<syntaxhighlight lang="rust">
match some_value {
    Some(x) => "you received a value!",
    None    => None,
}
}
</syntaxhighlight>
</syntaxhighlight>
</blockquote><!-- Matching Option -->
</blockquote><!-- Pattern Matching -->
</blockquote><!-- Pattern Matching -->

Revision as of 22:03, 7 February 2023

if statement

if num < 5 {
    // ..
} else if {
    // ..
} else {
    // ..
}

assign if

let weather = if season == "fall" { "lovely" } else { "fine I guess" } // ternary operator

match

Basics

Like a switch statement,
but the compiler ensures the entire valid range of items is checked for.
especially useful for enums.

In the following case, if _ was omitted
you'd need to ensure the full range of possible i32 numbers were supported!.

// if num is '1', returns 'a'
// if num is >2, returns 'c'
let result = match num {
    1 => "a",
    2 => "b",
    _ => "c",   // anything other than 1 or 2
}

You can match multiple values

let result = match num {
    1 | 3 | 5 => "one three or five",
    _ => "something else"
}

Matching Enums

When matching a parametrized enum, you can access the tuple/struct/value that is bound to it

enum Pet {
    Cat(String, u8),
    Dog{name: String, age: u8},
    Lizard(u8),
}

let pet = Pet::Lizard(5);
match pet {
    Pet::Cat(name, age) => { format!("cat, name={}, age={}", name, age) },
    Pet::Dog(dog)       => { format!("dog, name={dog.name}, age={dog.age}") },
    Pet::Lizard(age)    => { format!("lizard, age={}", age) }
}

Matching Option

Option is just an enum, generally if you don't have a specific behaviour for None,
you return a new None in that branch.
However this an opportunity to fail if it is an appropriate location for it.

match some_value {
    Some(x) => "you received a value!",
    None    => None,
}