Crate if_chain 

This crate provides a single macro called if_chain!.

If you’re using Rust 1.88 or newer, check out if let chains instead. This crate is still available for earlier versions of Rust.

if_chain! lets you write long chains of nested if and if let statements without the associated rightward drift. It also supports multiple patterns (e.g. if let Foo(a) | Bar(a) = b) in places where Rust would normally not allow them.

See the associated blog post for the background behind this crate.

Note about recursion limits

If you run into “recursion limit reached” errors while using this macro, try adding

#![recursion_limit = "1000"]

to the top of your crate.

Examples

Quick start

if_chain! {
    if let Some(y) = x;
    if y.len() == 2;
    if let Some(z) = y;
    then {
        do_stuff_with(z);
    }
}

becomes

if let Some(y) = x {
    if y.len() == 2 {
        if let Some(z) = y {
            do_stuff_with(z);
        }
    }
}

Fallback values with else

if_chain! {
    if let Some(y) = x;
    if let Some(z) = y;
    then {
        do_stuff_with(z)
    } else {
        do_something_else()
    }
}

becomes

if let Some(y) = x {
    if let Some(z) = y {
        do_stuff_with(z)
    } else {
        do_something_else()
    }
} else {
    do_something_else()
}

Intermediate variables with let

if_chain! {
    if let Some(y) = x;
    let z = y.some().complicated().expression();
    if z == 42;
    then {
       do_stuff_with(y);
    }
}

becomes

if let Some(y) = x {
    let z = y.some().complicated().expression();
    if z == 42 {
        do_stuff_with(y);
    }
}

Type ascription

let mut x = some_generic_computation();
if_chain! {
    if x > 7;
    let y: u32 = another_generic_computation();
    then { x += y }
    else { x += 1 }
}

becomes

let mut x = some_generic_computation();
if x > 7 {
    let y: u32 = another_generic_computation();
    x += y
} else {
    x += 1
}

Multiple patterns

if_chain! {
    if let Foo(y) | Bar(y) | Baz(y) = x;
    let Bubbles(z) | Buttercup(z) | Blossom(z) = y;
    then { do_stuff_with(z) }
}

becomes

match x {
    Foo(y) | Bar(y) | Baz(y) => match y {
        Bubbles(z) | Buttercup(z) | Blossom(z) => do_stuff_with(z)
    },
    _ => {}
}

Note that if you use a plain let, then if_chain! assumes that the pattern is irrefutable (always matches) and doesn’t add a fallback branch.

Macros

if_chain

Macro for writing nested if let expressions.