if let

For some use cases, when matching enums, match is awkward. For example:

  1. // Make `optional` of type `Option<i32>`
  2. let optional = Some(7);
  4. match optional {
  5.     Some(i) => {
  6.         println!("This is a really long string and `{:?}`", i);
  7.         // ^ Needed 2 indentations just so we could destructure
  8.         // `i` from the option.
  9.     },
  10.     _ => {},
  11.     // ^ Required because `match` is exhaustive. Doesn't it seem
  12.     // like wasted space?
  13. };

if let is cleaner for this use case and in addition allows various
failure options to be specified:

  1. fn main() {
  2.     // All have type `Option<i32>`
  3.     let number = Some(7);
  4.     let letter: Option<i32> = None;
  5.     let emoticon: Option<i32> = None;
  7.     // The `if let` construct reads: "if `let` destructures `number` into
  8.     // `Some(i)`, evaluate the block (`{}`).
  9.     if let Some(i) = number {
  10.         println!("Matched {:?}!", i);
  11.     }
  13.     // If you need to specify a failure, use an else:
  14.     if let Some(i) = letter {
  15.         println!("Matched {:?}!", i);
  16.     } else {
  17.         // Destructure failed. Change to the failure case.
  18.         println!("Didn't match a number. Let's go with a letter!");
  19.     };
  21.     // Provide an altered failing condition.
  22.     let i_like_letters = false;
  24.     if let Some(i) = emoticon {
  25.         println!("Matched {:?}!", i);
  26.     // Destructure failed. Evaluate an `else if` condition to see if the
  27.     // alternate failure branch should be taken:
  28.     } else if i_like_letters {
  29.         println!("Didn't match a number. Let's go with a letter!");
  30.     } else {
  31.         // The condition evaluated false. This branch is the default:
  32.         println!("I don't like letters. Let's go with an emoticon :)!");
  33.     };
  34. }

In the same way, if let can be used to match any enum value:

  1. // Our example enum
  2. enum Foo {
  3.     Bar,
  4.     Baz,
  5.     Qux(u32)
  6. }
  8. fn main() {
  9.     // Create example variables
  10.     let a = Foo::Bar;
  11.     let b = Foo::Baz;
  12.     let c = Foo::Qux(100);
  14.     // Variable a matches Foo::Bar
  15.     if let Foo::Bar = a {
  16.         println!("a is foobar");
  17.     }
  19.     // Variable b does not match Foo::Bar
  20.     // So this will print nothing
  21.     if let Foo::Bar = b {
  22.         println!("b is foobar");
  23.     }
  25.     // Variable c matches Foo::Qux which has a value
  26.     // Similar to Some() in the previous example
  27.     if let Foo::Qux(value) = c {
  28.         println!("c is {}", value);
  29.     }
  30. }

See also:

enum, Option, and the RFC