Result and recoverable errors

A typed student mark may still arrive as invalid text. Result represents success as Ok(value) and failure as Err(error). It makes a recoverable failure part of the function’s contract rather than pretending every input can produce a valid mark.

Parse attempts to interpret the text. map_err translates an error into the application’s chosen message, and ? returns early from a compatible Result-returning function when an operation fails. A separate range check is still needed after parsing succeeds.

Save the complete source as main.rs in the Rust environment. No standard input is needed.

Rust 2024 · complete program

fn parse_score(text: &str) -> Result<u32, String> {
  let score = text.trim().parse::<u32>().map_err(|_| "Use a whole number".to_string())?;
  if score > 100 { return Err("Use a mark from 0 to 100".to_string()); }
  Ok(score)
}
fn main() {
  for text in ["80", "eighty", "120"] {
    match parse_score(text) {
      Ok(score) => println!("Score: {score}"),
      Err(message) => println!("Check: {message}"),
    }
  }
}

Expected output

Score: 80
Check: Use a whole number
Check: Use a mark from 0 to 100

Follow the execution

Eighty parses and passes the range check. Eighty written as a word fails parsing, so ? returns the mapped error early. The text 120 parses successfully but fails the independent domain check. Main handles each Result without terminating the entire report.

Try the complete program in the Rust compiler. For tests, Cargo commands and local files, use the specified local environment.

Your task: Why is successful parsing not enough to accept 120?

Rust 2024 · complete program

fn parse_score(text: &str) -> Result<u32, String> {
  let score = text.trim().parse::<u32>().map_err(|_| "Use a whole number".to_string())?;
  if score > 100 { return Err("Use a mark from 0 to 100".to_string()); }
  Ok(score)
}
fn main() {
  for text in ["80", "eighty", "120"] {
    match parse_score(text) {
      Ok(score) => println!("Score: {score}"),
      Err(message) => println!("Check: {message}"),
    }
  }
}

Worked answer

Parsing establishes that the text represents a u32. It does not establish that the mark meets the school’s permitted 0-to-100 range.

Panic is usually unsuitable for ordinary invalid user input. Production error types can retain structured information instead of only strings. The ? operator requires a compatible return context; it is not a universal exception handler.

Parsing establishes that the text represents a u32. It does not establish that the mark meets the school’s permitted 0-to-100 range. Panic is usually unsuitable for ordinary invalid user input.

Further reading: the official Rust Book on result and recoverable errors.