# [−][src]Crate if_chain

This crate provides a single macro called `if_chain!`.

`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.

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.