I am learning Rust from yesterday. The following code is simple -- 

```rust
use encoding_rs::Encoding;
use std::fs;
use std::fs::File;
use std::io::BufReader;
use std::io::Read;
use std::option::Option;
use std::path::Path;

extern crate encoding_rs;
extern crate encoding_rs_io;

fn main() {
    let mut reader = BufReader::new(file);
    let mut bom: [u8; 3] = [0; 3];

    // read BOM
    if let Ok(_) = reader.read_exact(&mut bom) {
        // sniff BOM

        // Because Rust disallows NULLs, hence I declare `Option<&Encoding>` to store the result of encoding.
        let mut enc: Option<&Encoding> = None;
        match Encoding::for_bom(&bom) {
            Some((encoding, _)) => {
                // <-- Some((enc, _))
                enc = Some(encoding);
            }
            None => {
                if let Some(encoding) = Encoding::for_label("UTF-8".as_bytes()) {
                    enc = Some(encoding);
                }
            }
        }

        if let Some(encoding) = enc {
            println!("{:?}", encoding);
        }
    }
}

```

It opens a text file, and try to analyze its encoding by parsing BOM(Byte Order Marker). If `Encoding::for_bom` does not return an encoding, the code will take use `UTF-8` as default. 

I dislike `unwrap()` because it always assume there is a valid result

My question is : is there a way to do pattern matching and put the result directly into an existing mutable binding?

e.g. Change `Some((encoding, _))` to `Some((enc, _))` hence I don't need the line of `enc = Some(encoding)`