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 challenge, 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

And1

and1

a day ago

2.98ms

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("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string())
    }
}

michdorf

a day ago

3.07ms

81.43kb

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

Javier Garcia

javigar322

a day ago

3.07ms

81.43kb

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

Giuliano

GiulianoCTRL

2 days ago

2.82ms

81.43kb

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

mgreve

2 days ago

3.70ms

86.78kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let mut n:u8 = 0;
    for c in input.chars() {
        println!("{}", c);
        if '0' <= c && c <= '9' {
            n = n*10 + c.to_digit(10).unwrap() as u8;
        } else {
            return Result::Err("Invalid input".into());
        }
        if n > 100 {
            return Result::Err("Percentage out of range".into());
        } 
    }
    Result::Ok(n)
}

Shoma Kobayashi

kobapi28

3 days ago

4.53ms

85.89kb

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

Len Remmerswaal

LenRemmerswaal

3 days ago

3.39ms

81.43kb

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

Len Remmerswaal

LenRemmerswaal

3 days ago

3.26ms

81.43kb

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

Galen Seilis

galenseilis

3 days ago

4.16ms

86.76kb

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

Thitiworada

Kobeieii

4 days ago

3.52ms

81.43kb

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

Jaden Wijata

xenonminer

4 days ago

3.22ms

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 {
                return Err("Percentage out of range".into());
            };
            return Ok(percentage)
        },
        Err(_) => Err("Invalid input".into())
    }
}

Kenneth Love

kennethlove

4 days ago

2.87ms

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 {
                return Err("Percentage out of range".into())
            };
            return Ok(percentage)
        },
        Err(_) => Err("Invalid input".into())
    }
}

Tobiasz

tobiaszfilar

4 days ago

2.76ms

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 {
                return Ok(n)
            }
            return Err("Percentage out of range".to_string())
        }
        Err(_) => Err("Invalid input".to_string())
    }
}

kylenoteboom

4 days ago

3.69ms

81.43kb

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

5822791760

5 days ago

3.65ms

81.43kb

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

arilet

5 days ago

2.74ms

81.43kb

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

martin-unit

5 days ago

2.71ms

81.43kb

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

Jim Lawton

jimlawton

5 days ago

2.84ms

81.43kb

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

Esteban Soba

XtebanUy

5 days ago

2.84ms

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 @ 0..=100) => Ok(n),
        _ => Err("Percentage out of range".to_string())
    }
}

Markus Bergkvist

mbergkvist

5 days ago

2.93ms

81.43kb

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

Thitiworada

Kobeieii

6 days ago

3.68ms

81.43kb

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

Ando “Thor” Nando

DivineGod

6 days ago

2.95ms

81.43kb

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

Andreas

StimhackSoftware

6 days ago

3.45ms

81.43kb

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

Algorab

6 days ago

3.20ms

81.43kb

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

Stefan Roas

sroas

7 days ago

5.38ms

85.89kb

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

xiuchiliudu

7 days ago

2.90ms

81.43kb

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

qiyuan711

8 days ago

3.04ms

81.43kb

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

yoakemae

8 days ago

2.94ms

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 {
                return Ok(num);
            } else {
                return Err("Percentage out of range".to_string());
            }
        },
        Err(_) => return Err("Invalid input".to_string()),
    };
}

Jan Willems

8 days ago

3.05ms

85.89kb

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

Nt2311

nt2311-vn

8 days ago

4.13ms

81.43kb

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

tinthid

8 days ago

3.00ms

85.89kb

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

devarajang

8 days ago

3.00ms

81.43kb

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

Jörg Erdmenger

joeslow

8 days ago

3.51ms

81.43kb

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

Philip Mercer

DV-13

8 days ago

2.74ms

81.43kb

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

Philip Mercer

DV-13

8 days ago

3.05ms

81.43kb

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

Elizabeth Doughty

Thymelizabeth

9 days ago

5.73ms

81.43kb

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

oDqnger

10 days ago

3.42ms

81.43kb

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

oDqnger

10 days ago

6.15ms

81.43kb

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

Masayuki Sunahara

tamanishi

10 days ago

4.49ms

81.43kb

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

s.konishi

konishu

10 days ago

5.03ms

81.43kb

// pub fn parse_percentage(input: &str) -> Result<u8, String> {
//     // 文字列をパースして数値に変換
//     let parsed_percentage = match input.parse::<u8>() {
//         Ok(hoge) => hoge,
//         Err(_) => return Err("Invalid input".to_string()), // カスタムエラーメッセージ
//     };
//     // 値が範囲内にあるかチェック
//     if parsed_percentage > 100 {
//         Err("Percentage out of range".to_string())
//     } else {
//         Ok(parsed_percentage)
//     }
// }
pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let parsed_percentage = match input.parse::<u8>() {
        Ok(value) => value,
        Err(_) => return Err("Invalid input".to_string()),
    };
    if parsed_percentage > 100 {
        Err("Percentage out of range".to_string())
    } else {
        Ok(parsed_percentage)
    }
}

s.konishi

konishu

10 days ago

4.32ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // 文字列をパースして数値に変換
    let parsed_percentage = match input.parse::<u8>() {
        Ok(hoge) => hoge,
        Err(_) => return Err("Invalid input".to_string()), // カスタムエラーメッセージ
    };
    // 値が範囲内にあるかチェック
    if parsed_percentage > 100 {
        Err("Percentage out of range".to_string())
    } else {
        Ok(parsed_percentage)
    }
}

nichideropa

10 days ago

3.04ms

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 => Ok(percentage),
        // This handles the cases in which the before mentioned pattern
        // doesn't match
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) =>  Err("Invalid input".to_string()),
    }
}

Jan

jeypiti

10 days ago

2.99ms

81.43kb

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

0xsmarter

11 days ago

2.99ms

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 => Ok(percentage),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
}

Oebelus

oebelus

11 days ago

3.18ms

81.43kb

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

tsuchiya-d

tsucchinoko

12 days ago

2.86ms

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 => Ok(percentage),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
}

Lauri Sarap

LauriSarap

12 days ago

2.80ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let removed_input_symbol = input.trim_end_matches('%');
    match removed_input_symbol.parse::<u8>() {
        Ok(value) if value <= 100 => Ok(value),
        Ok(_) => Err(format!("Percentage out of range")),
        Err(_) => Err(format!("Invalid input")),
    }
}

Ankeet Parikh

ankeetparikh

12 days ago

3.26ms

81.43kb

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

Nero22k

12 days ago

2.99ms

81.43kb

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

maxvi

12 days ago

2.81ms

81.43kb

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