Is there an idiomatic way of chaining Option in Rust?

Question

When deserializing deeply nested structures (e.g. from JSON), it's not uncommon to have to traverse multiple Option types.

For example:

let foo = Foo {
    x: Some(Bar {
        y: Some(Baz {
            z: Some(42),
        })
    })
};

Is there an idiomatic way of chaining Option to access deeply nested values?

So far I have the following, but neither are as concise as foo.x?.y?.z in other languages that support optional-chaining:

let z = foo.x.as_ref().and_then(|x| x.y.as_ref()).and_then(|y| y.z);
let z = foo.x.as_ref().and_then(|x| x.y.as_ref()?.z);
let z = (|| foo.x.as_ref()?.y.as_ref()?.z)();

---

It looks like the try_block feature might be a good fit, but it's currently unstable.

let z = try { foo.x.as_ref()?.y.as_ref()?.z };

Answer 1

As you say, the try block would be perfect for this.

In the meantime you can take advantage of the fact that ? works in functions, and wrap your expression in a closure and call it:

let z = (|| foo.x.as_ref()?.y.as_ref()?.z )();

You can write a simple macro to make it a bit nicer:

macro_rules! tryit {
    ($($e: tt)+) => {
        (|| { $($e)+ })()
    }
}

Which works basically the same as the try block:

let z = tryit! { foo.x.as_ref()?.y.as_ref()?.z };

Answer 2

Another option if you don't like the immediately called closure is to use a crate like map_for or mdo. Example with map_for:

use map_for::option::FlatMap;
let z = map_for!{
    x <- foo.x.as_ref();
    y <- x.y.as_ref();
    => y.z }:

Disclaimer: I wrote the map_for crate.

Answer 3

Another option is to use destructuring with if let:

struct Foo {
    x: Option<Bar>,
}
struct Bar {
    y: Option<Baz>,
}
struct Baz {
    z: Option<i32>,
}

fn main() {
    let foo = Foo {
        x: Some(Bar {
            y: Some(Baz { z: Some(42) }),
        }),
    };

    if let Foo {
        x: Some(Bar {
            y: Some(Baz { z: Some(num) }),
        }),
    } = &foo
    {
        println!("contains number: {}", num);
    }
}

contains number: 42