Rust vs. C++: Fine-grained Performance(cantrip.org)

  3.8 Branch prediction in Intel Haswell, Broadwell and Skylake

  The branch predictor appears to have been redesigned in the 
  Haswell, but very little is known about its construction.

  The measured throughput for jumps and branches varies 
  between one branch per clock cycle and one branch per two 
  clock cycles for jumps and predicted taken branches. 
  Predicted not taken branches have an even higher throughput   
  of up to two branches per clock cycle.

  The high throughput for taken branches of one per clock was 
  observed for up to 128 branches with no more than one 
  branch per 16 bytes of code. If there is more than one 
  branch per 16 bytes of code then the throughput is reduced 
  to one jump per two clock cycles. If there are more than 
  128 branches in the critical part of the code, and if they 
  are spaced by at least 16 bytes, then apparently the first 
  128 branches have the high throughput and the remaining 
  have the low throughput.

  These observations may indicate that there are two branch 
  prediction methods: a fast method tied to the μop cache and 
  the instruction cache, and a slower method using a branch 
  target buffer.

  let fname = &*env::args().nth(1).unwrap_or("/usr/share/dict/words".into());

     let file: Box<Read> = match fname {
            "-" => Box::new(stdin.lock()),
             _  => Box::new(fs::File::open(fname).unwrap_or_else(|err| {
                     writeln!(io::stderr(), "{}: \"{}\"", err, fname).unwrap();
                     process::exit(1);
                 }))
        };

    date.if_weekday(|day| { ... }) 

    Incidentally, I don’t know why I can write  
        let (mut word, mut len, mut ones) = (0u32, 0, 0);
    but not
        (word, len, ones) = (0, 0, 0);