Graceful error handling

One of the most loved features of Rust is the way it lets you handle errors. The Result type is a powerful tool that allows you to handle errors in a way that is both safe and expressive. In this challenge, you will be working with the Result<T, E> type to handle errors in a graceful way.

The Result<T, E> itself is an enum that has two variants: Ok(T) and Err(E). The Ok variant is used to represent a successful computation that returns a value of type T. The Err variant is used to represent an error that returns a value of type E.

When you have a function that can fail, you can use the Result type to return the result of the computation. If the computation is successful, you can return the success variant of Result with the value of the computation. If the computation fails, you can return the error variant of Result with an error message that explains what went wrong.

Your task

In this challenges, you're given a function, parse_percentage(input: &str) -> Result<u8, String> that takes a string as input and returns a Result type. The function should parse the input string as a percentage and return the percentage as a u8 if the input is valid. If the input is invalid, the function should return an error message as a String.

Parsing from a string to a number can fail for many reasons. For example, the input string may not be a valid number, or it may be a valid number but not a valid percentage. Your task is to handle these errors gracefully and return an error message that explains what went wrong.

Complete the function, if the parsing was successful return a success variant of the Result, if there was an error in parsing, return an error variant of the Result with an error message.

Requirements

If the parse was successful, the function should return the success variant of Result with the percentage as a u8.
If the number was out of range (not between 0 and 100), the function should return the error with String "Percentage out of range".
If the string was not a valid number, the function should return the error with String "Invalid input".

Example

let result = parse_percentage("50");
assert_eq!(result, Ok(50));
 
let result = parse_percentage("101");
assert_eq!(result, Err("Percentage out of range".to_string()));
 
let result = parse_percentage("abc");
assert_eq!(result, Err("Invalid input".to_string()));

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Carlos Arias

carlos-quantexai

3 hours ago

2.33ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let parsed_value: Result<u8, _> = input.parse(); // Store the parsed value
    if let Ok(value) = parsed_value {
        if value >= 0 && value <= 100 { // Use logical AND
            return Ok(value);
        } else {
            return Err("Percentage out of range".to_string());
        }
    } else {
        return Err("Invalid input".to_string());
    }
}

Maki-SIO

3 hours ago

2.31ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let mut num: u8 = 0;
    match input.parse::<u8>() {
        Ok(v) => num = v,
        Err(e) => return Err(String::from("Invalid input")),
    };
    if num > 100 || num < 0 {
        return Err(String::from("Percentage out of range"));
    } else {
        return Ok(num);
    }
}

Maxence Potier

Mxn-ptr

4 hours ago

2.33ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(num) if num <= 100 => Ok(num),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string())
    }
}

Daniel Yan

yansq

8 hours ago

2.65ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Err(_) => Err("Invalid input".to_string()),
        Ok(n) if n > 100 => Err("Percentage out of range".to_string()),
        Ok(n) => Ok(n)
    }
}

zelsazgh

9 hours ago

2.14ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(num) if num<=100 => Ok(num),
        Ok(_) => Err(format!("Percentage out of range")),
        Err(_) => Err(format!("Invalid input")),
    }
}

funny_233

funny233-github

11 hours ago

2.22ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(num) if num <= 100 => Ok(num),
        Ok(_) => Err(format!("Percentage out of range")),
        Err(_) => Err(format!("Invalid input")),
    }
}

José Bernardo

jose-bernardo

15 hours ago

2.30ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(number) if number > 100 => Err("Percentage out of range".to_string()),
        Ok(number) => Ok(number),
        Err(_e) => Err("Invalid input".to_string()),
    }
}

Delta Regeer

digitalresistor

20 hours ago

2.30ms

81.43kb


pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.trim().parse::<u8>() {
        Ok(n) if n > 100 => Err("Percentage out of range".to_string()),
        Ok(n) => Ok(n),
        Err(_) => Err("Invalid input".to_string()),
    }
}

Average Joe

Karivelia

a day ago

2.30ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    if let Ok(x) = input.parse::<u8>(){
        if x > 100 {
            return Err("Percentage out of range".to_string());
        }
        return Ok(x);
    }
    Err("Invalid input".to_string())
}

Logan Radloff

radloffl

a day ago

2.22ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(i) if i < 101 => Ok(i),
        Err(_) => Err("Invalid input".to_string()),
        _ => Err("Percentage out of range".to_string())
    }
}

majesticalcreature

a day ago

2.31ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let parsed = input.parse();
    let n: u8;
    match parsed {
        Ok(num) => n = num,
        Err(_) => return Err(String::from("Invalid input"))
    }
    if n > 100 {
        return Err(String::from("Percentage out of range"));
    }
    Ok(n)
}

今何求

jhq223

2 days ago

2.42ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(n) => {
            if n <= 100 { Ok(n) } else { Err("Percentage out of range".to_string()) }
        }
        Err(_) => { Err("Invalid input".to_string()) }
    }
}

Will Barnett

xbarnett

2 days ago

2.34ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let Ok(n) = input.parse::<u8>() else {
        return Err(String::from("Invalid input"))
    };
    if 0 <= n && n <= 100 {
        Ok(n)
    } else {
        Err(String::from("Percentage out of range"))
    }
}

Mikhail

mk-comm

2 days ago

2.22ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let parsed= input.parse();
    let parsed = match parsed {
        Ok(value) => value,
        Err(_) => return Err("Invalid input".to_string())
    } ;
    if parsed > 100 {
        return Err("Percentage out of range".to_string())
    }
    Ok(parsed)
}

Johnchoi913

2 days ago

2.40ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let input_result = input.parse::<u8>();
    match input_result {
        Err(_) => return Err("Invalid input".to_string()),
        Ok(T) => {
            if T <= 100 {
                return Ok(T);
            } else {
                return Err("Percentage out of range".to_string());
            }
        },
    }
}

Laurențiu STOLERIU

LaurentiuStoleriu

2 days ago

2.60ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let percent = input.parse::<u8>();
    match percent {
        Ok(value) => {
            if value > 100u8 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(value)
            }
        },
        Err(_) => Err("Invalid input".to_string())
    }  
}

Matei Stefanescu

matei

2 days ago

2.26ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.trim().parse::<u8>() {
        Ok(num) if num <= 100 => Ok(num),
        Ok(_) => Err(String::from("Percentage out of range")),
        Err(_) => Err(String::from("Invalid input"))
    }
}

sander-b-postnl

2 days ago

2.31ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(n) if n <= 100 => Ok(n),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
}

amassare

2 days ago

2.28ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse(){
        Err(_)=>Err(String::from("Invalid input")),
        Ok(num@0..=100)=>Ok(num),
        Ok(_)=>Err(String::from("Percentage out of range"))
    }
}

Oleksandr Romanov

alexromanov

2 days ago

2.40ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n) if (0..=100).contains(&n) => Ok(n),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
}

IdoPort

2 days ago

2.44ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse() {
        Ok(num) => if num <= 100 {Ok(num)} else {Err("Percentage out of range".to_string())}
        _ => Err("Invalid input".to_string())
    }
}

Ustin

2 days ago

2.25ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse() {
        Ok(num) => if num <= 100 {Ok(num)} else {Err("Percentage out of range".to_string())},
        _ => Err("Invalid input".to_string())
    }
}

Joel Vicente Filho

kyhou

3 days ago

2.23ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    if let Ok(n) = input.parse() {
        match n {
            n if n >= 0 && n <= 100 => Ok(n),
            _ => Err("Percentage out of range".to_string()),
        }
    } else {
        Err("Invalid input".to_string())
    }
}

Adi

Aditeya

3 days ago

2.28ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let Ok(num) = u8::from_str_radix(input, 10) else {
        return Err("Invalid input".to_string());
    };
    if num > 100 {
        return Err("Percentage out of range".to_string());
    }
    Ok(num)
}

Stefano Cianciulli

CianciuStyles

3 days ago

2.34ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(valid) if (0..=100).contains(&valid) => Ok(valid),
        Ok(_) => Err(String::from("Percentage out of range")),
        Err(_) => Err(String::from("Invalid input"))
    }
}

Ayush Rawat

ayushrawat10

3 days ago

2.28ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(n) if (0..=100).contains(&n) => Ok(n),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
}

Patrik Bjärterot

pbjarterot

3 days ago

2.37ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(num) => {
            if num >= 0 && num <= 100 {
                return Ok(num)
            } else {
                return Err("Percentage out of range".to_string())
            }
        }
        Err(_) => return Err("Invalid input".to_string())
    }
}

masteryachty

3 days ago

2.32ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let percent = input.parse::<u8>();
    match percent {
        Ok(value) => {
            if value > 100u8 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(value)
            }
        },
        Err(_) => Err("Invalid input".to_string())
    }  
}

damascussteel21

3 days ago

2.38ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    if let Ok(perc) = input.parse::<u8>() {
        if perc <= 100 {
            Ok(perc)
        } else {
            Err(String::from("Percentage out of range"))
        }
    } else {
        Err(String::from("Invalid input"))
    }
}

John Truong

jtruong04

4 days ago

2.29ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let percent = input.parse::<u8>();
    match percent {
        Ok(value) => {
            if value > 100u8 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(value)
            }
        },
        Err(_) => Err("Invalid input".to_string())
    }  
}

Abhiyan Chhetri

abhiyan-chhetri

4 days ago

2.43ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.trim().parse::<u8>() {
        Ok(value) if value <= 100 => Ok(value),
        Ok(_) => Err("Percentage out of range".to_string()),
        _ => Err("Invalid input".to_string()),
    }
}

Ojash Neopane

oneopane

4 days ago

2.22ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.trim().parse::<u8>() {
        Ok(value) if value <= 100 => Ok(value),
        Ok(_) => Err("Percentage out of range".to_string()),
        _ => Err("Invalid input".to_string()),
    }
}

Edgar Christian

edgarcnp

4 days ago

2.16ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.trim().parse::<u8>() {
        Ok(value) if value <= 100 => Ok(value),
        Ok(_) => Err("Percentage out of range".to_string()),
        _ => Err("Invalid input".to_string())
    }
}

Samuel

Sommos

4 days ago

2.32ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let percent = input.parse::<u8>().map_err(|_| "Invalid input".to_string())?;
    if percent > 100 {
        Err("Percentage out of range".to_string())
    } else {
        Ok(percent)
    }
}

Christian Franzl

wischi-chr

4 days ago

2.33ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let percent = input.parse::<u8>().map_err(|_| "Invalid input".to_string())?;
    if percent > 100 {
        Err("Percentage out of range".to_string())
    } else
    {
        Ok(percent)
    }
}

Tukan van der Borgh

tukantje

4 days ago

2.39ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    input
        .parse::<u32>()
        .map_err(|_| "Invalid input".to_string())
        .and_then(|num| match num {
            0..=100 => Ok(num as u8),
            _ => Err("Percentage out of range".to_string())
        })
}

Gareth Andrew Lloyd

Ignition

4 days ago

2.24ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    input
        .parse::<u32>()
        .map_err(|_| "Invalid input".to_string())
        .and_then(|num| {
            match num {
                0..=100 => Ok(num as u8),
                _ => Err("Percentage out of range".to_string())
            }
        })
}

Danny Yoo

dyoo

5 days ago

2.25ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let p: u8 = input.parse().map_err(|_| "Invalid input".to_string())?;
    if p <= 100 {
        Ok(p)        
    } else {
        Err("Percentage out of range".to_string())
    }
    // TODO: Implement the function here
}

Jason Green

jaswgreen

5 days ago

2.10ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(percentage) => if percentage > 100 {
            Err("Percentage out of range".to_string())
        } else {
            Ok(percentage)
        },
        _ => Err("Invalid input".to_string())
    }
}

Nicolás Caracci

hilias

5 days ago

2.61ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse() {
        Ok(percentage) => if percentage > 100 {
            Err("Percentage out of range".to_string())
        } else {
            Ok(percentage)
        },
        Err(_) => Err("Invalid input".to_string())
    }
}

CarrotTarrot

5 days ago

2.30ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let number = match input.parse::<u8>() {
        Ok(number) => number,
        Err(_) => return Err("Invalid input".to_string())
    };
    if number > 100 {
        return Err("Percentage out of range".to_string());
    }
    Ok(number)
}

Quentin Cabanes

qcabanes-hobby

5 days ago

2.23ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    if let Ok(n) = input.parse() {
        match n {
            0..=100 => Ok(n),
            _ => Err("Percentage out of range".to_string()),
        }
    } else {
        Err("Invalid input".to_string())
    }
}

TaiPoole

5 days ago

2.25ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse() {
        Ok(num) => match num {
            0..=100 => Ok(num),
            _ => Err("Percentage out of range".to_string())
        }
        Err(_) => Err("Invalid input".to_string()) 
    }
}

Hin Phansa

hinphansa

5 days ago

2.53ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n) if n <= 100 => Ok(n as u8),
        Ok(_) => Err("Percentage out of range".to_string()),
        _ => Err("Invalid input".to_string()),
    }
}

Hin Phansa

hinphansa

5 days ago

2.31ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n) => {
            if n > 100 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(n)
            }
        }
        Err(_) => Err("Invalid input".to_string()),
    }
}

Hin Phansa

hinphansa

5 days ago

2.42ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse() as Result<u8, _> {
        Ok(x) => {
            if x > 100 {
                return Err("Percentage out of range".to_string());
            }
            return Ok(x);
        }
        Err(_) => {
            return Err("Invalid input".to_string());
        }
    }
}

TomBaston

5 days ago

2.26ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n) => match n {
            0..=100 => Ok(n),
            _ => Err("Percentage out of range".into())
        },
        _ => Err("Invalid input".into())
    }
}

Amin

Shorakie

5 days ago

2.24ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(number) if number <= 100 => Ok(number),
        Ok(_) => Err(String::from("Percentage out of range")),
        Err(_) =>  Err(String::from("Invalid input")),
    }
}

Amin

Shorakie

5 days ago

2.20ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(number) if number <= 100 => Ok(number),
        Ok(number) => Err(String::from("Percentage out of range")),
        Err(_) =>  Err(String::from("Invalid input")),
    }
}

swandyr

5 days ago

2.31ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse() {
        Err(_) => Err("Invalid input".into()),
        Ok(n) if n > 100 => Err("Percentage out of range".into()),
        Ok(n) => Ok(n),
    }
}