Guessing game, error on shadowing guess bind

Question

I'm following the Rust tutorial but I'm stuck on this code (the last snippet in the page):

extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is {}", secret_number);

    loop {
        println!("Please input your guess");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        }

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less      => println!("Too small!"),
            Ordering::Greater   => println!("Too big!"),
            Ordering::Equal     => {
                println!("You win!");
                break;
            }
        }
    }
}

When I run cargo run I have the following error:

src/main.rs:23:47: 23:48 error: expected one of `.`, `;`, or an operator, found `{`
src/main.rs:23         let guess: u32 = guess.trim().parse() {
                                                             ^

What's the right syntax?

Answer 1

There is a syntax error and the compiler message is directing your attention to the wrong place on the line to fix the problem.

The parse method evaluates to a value. This expression should not be followed by a block, causing the syntax error reported by the compiler.

https://doc.rust-lang.org/std/string/struct.String.html#method.parse

The example you linked to has the keyword match between the assignment and call to parse. The match keyword takes an expression and branches based on the value of the expression. The block contains the branching patterns and expressions. In this case it is also destructuring the Result into either an u32 or u32::Err.

https://doc.rust-lang.org/book/match.html

Below is an example that separates the parse and match for clarity.

// Store result of parsing in a variable
let parse_result = guess.trim().parse();
// Destructure the result
let guess: u32 = match parse_result {
    // If parse succeeded evaluate to the number
    Ok(num) => num,
    // If parse failed repeat the loop
    Err(_) => continue,
};