Day 13: Santa's error handling rant

Santa found it a good opportunity to have a look to see what Blitzen has been doing all this time when he was tech lead.

Rolling up his sleeves, he ran a git diff command and began scrolling through the commits. His candy-cane-themed monitor reflected the code as his eyes narrowed like a debugger catching a null pointer. Then he froze, staring at the parse_row function.

"Blitzen," he barked, "what is this disaster? return &'static str for errors? Seriously?!"

Blitzen shrugged, sipping his oat milk latte. "MVP, Santa. Move fast, y'know?"

Santa slammed his mug of hot coffee down, marshmallows flying. "MVP? Last time you were in charge, you tried to rewrite grep and cat in Rust because you were 'bored'! And now you're telling me you can't handle proper error types? It takes five minutes! Do you want runtime panics for Christmas?!"

Bernard leaned in. "What if we use an enum? Variants for different errors, match on them later. Clean, ergonomic."

Santa's face lit up like Rudolph's nose. "Finally, a solution that doesn't make me want to refactor the North Pole. Bernard, you get an extra cookie ration this year. Blitzen? No oat lattes for a week."

Blitzen sighed. "Enum it is."

Your Mission

Create an enum called ParseError with a few variants:
- NoName
- NoGoodDeeds
- NoBadDeeds
- InvalidGoodDeeds
- InvalidBadDeeds
When errors displayed, they should be human-readable:
- ParseError::NoName should display as "Name field is missing"
- ParseError::NoGoodDeeds should display as "Good deeds field is missing"
- ParseError::NoBadDeeds should display as "Bad deeds field is missing"
- ParseError::InvalidGoodDeeds should display as "Good deeds value is invalid"
- ParseError::InvalidBadDeeds should display as "Bad deeds value is invalid"
Implement the std::error::Error trait for ParseError.
Update the parse_row function to return meaningful errors using the ParseError enum.
Make sure you return the correct error variant for each error condition.
Handle the cases where an item in a row is missing. e.g. Alice,,3 in this case, you should return an error with the NoGoodDeeds variant.

Hints

If you're stuck or need a starting point, here are some hints to help you along the way!

Click here to show hints.

The Error trait requires you to implement the Display and Debug traits for the custom error type.
Implement Debug by using the derive macro. e.g. #[derive(Debug)]

For Display you must implement manually. e.g.

  use std::fmt;
 
  impl fmt::Display for ParseError {
      fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
          match self {
              ParseError::NoName => write!(f, "No name found"),
              // other variants...
          }
      }
  }

Now that both traits are implemented, you can implement the Error trait.
```
use std::error::Error;
 
impl Error for ParseError {}
```

Editor not available on Mobile!

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

Solutions

Francisco López

franlopezm

7 hours ago

4.62ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds
}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name.is_empty() {
            return Err(ParseError::NoName);
        }
        let good_deeds = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?;
        if good_deeds.is_empty() {
            return Err(ParseError::NoGoodDeeds);
        }
        let good_deeds = good_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?;
        if bad_deeds.is_empty() {
            return Err(ParseError::NoBadDeeds);
        }
        let bad_deeds = bad_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Mingzhe Yang

mei28

16 hours ago

3.78ms

89.24kb

use std::error::Error;
use std::fmt;
use std::fmt::{Debug, Display, Formatter};
use crate::ParseError::{InvalidBadDeeds, InvalidGoodDeeds, NoBadDeeds, NoGoodDeeds, NoName};
// Import the necessary modules
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Debug for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", match self {
            ParseError::NoName => {"Name field is missing"}
            ParseError::NoGoodDeeds => {"Good deeds field is missing"}
            ParseError::NoBadDeeds => {"Bad deeds field is missing"}
            ParseError::InvalidGoodDeeds => {"Good deeds value is invalid"}
            ParseError::InvalidBadDeeds => {"Bad deeds value is invalid"}
        })
    }
}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        fmt::Debug::fmt(self, f)
    }
}
impl Error for ParseError {
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
    
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(NoName)?.to_string();
        if name == "" {
            return Err(NoName);
        }
        let good_deeds = fields.next().ok_or(NoGoodDeeds)?;
        if good_deeds == "" {
            return Err(NoGoodDeeds);
        }
        let good_deeds = good_deeds.parse::<u32>().map_err(|_| InvalidGoodDeeds)?;
        let bad_deeds = fields.next().ok_or(NoBadDeeds)?;
        if bad_deeds == "" {
            return Err(NoBadDeeds);
        }
        let bad_deeds = bad_deeds.parse::<u32>().map_err(|_| InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Florian Gaudin-Delrieu

FlorianGD

16 hours ago

3.82ms

89.24kb

// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let message = match self {
            ParseError::NoName => "Name field is missing",
            ParseError::NoGoodDeeds => "Good deeds field is missing",
            ParseError::NoBadDeeds => "Bad deeds field is missing",
            ParseError::InvalidGoodDeeds => "Good deeds value is invalid",
            ParseError::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", message)
    }
}
// 2. Implement the Error trait for ParseError
impl std::error::Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name.is_empty() {
            return Err(ParseError::NoName)
        }
        let good_deeds = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?;
        if good_deeds.is_empty() {
            return Err(ParseError::NoGoodDeeds)
        }
        let good_deeds = good_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?;
        if bad_deeds.is_empty() {
            return Err(ParseError::NoBadDeeds)
        }
        let bad_deeds = bad_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Joseph Copenhaver

josephcopenhaver

19 hours ago

5.57ms

89.24kb

use std::fmt;
use std::error::Error;
// Import the necessary modules
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl fmt::Debug for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        write!(f, "{}", match self {
            ParseError::NoName => "Name field is missing",
            ParseError::NoGoodDeeds => "Good deeds field is missing",
            ParseError::NoBadDeeds => "Bad deeds field is missing",
            ParseError::InvalidGoodDeeds => "Good deeds value is invalid",
            ParseError::InvalidBadDeeds => "Bad deeds value is invalid",
        })
    }
}
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        fmt::Debug::fmt(self, f)
    }
}
// 2. Implement the Error trait for ParseError
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name == "" {
            return Err(ParseError::NoName);
        }
        let good_deeds = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?;
        if good_deeds == "" {
            return Err(ParseError::NoGoodDeeds)
        }
        let good_deeds = good_deeds.parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?;
        if bad_deeds == "" {
            return Err(ParseError::NoBadDeeds)
        }
        let bad_deeds = bad_deeds.parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

PangoSea

kapaseker

a day ago

3.90ms

89.24kb

use std::error::Error;
use std::fmt;
use std::fmt::{Debug, Display, Formatter};
use crate::ParseError::{InvalidBadDeeds, InvalidGoodDeeds, NoBadDeeds, NoGoodDeeds, NoName};
// Import the necessary modules
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Debug for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", match self {
            ParseError::NoName => {"Name field is missing"}
            ParseError::NoGoodDeeds => {"Good deeds field is missing"}
            ParseError::NoBadDeeds => {"Bad deeds field is missing"}
            ParseError::InvalidGoodDeeds => {"Good deeds value is invalid"}
            ParseError::InvalidBadDeeds => {"Bad deeds value is invalid"}
        })
    }
}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        fmt::Debug::fmt(self, f)
    }
}
impl Error for ParseError {
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
    
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(NoName)?.to_string();
        if name == "" {
            return Err(NoName);
        }
        let good_deeds = fields.next().ok_or(NoGoodDeeds)?;
        if good_deeds == "" {
            return Err(NoGoodDeeds);
        }
        let good_deeds = good_deeds.parse::<u32>().map_err(|_| InvalidGoodDeeds)?;
        let bad_deeds = fields.next().ok_or(NoBadDeeds)?;
        if bad_deeds == "" {
            return Err(NoBadDeeds);
        }
        let bad_deeds = bad_deeds.parse::<u32>().map_err(|_| InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Sympatron GmbH

Sympatron

a day ago

4.62ms

89.24kb

// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl std::error::Error for ParseError {}
impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}",
            match self {
                ParseError::NoName => "Name field is missing",
                ParseError::NoGoodDeeds  => "Good deeds field is missing",
                ParseError::NoBadDeeds  => "Bad deeds field is missing",
                ParseError::InvalidGoodDeeds  => "Good deeds value is invalid",
                ParseError::InvalidBadDeeds  => "Bad deeds value is invalid",
            }
        )
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name == "" { return Err(ParseError::NoName); }
        let good_deeds = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?;
        if good_deeds == "" { return Err(ParseError::NoGoodDeeds); }
        let good_deeds = good_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?;
        if bad_deeds == "" { return Err(ParseError::NoBadDeeds); }
        let bad_deeds = bad_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Marius Gehrmann

MGehrmann

a day ago

4.60ms

89.24kb

use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            // other variants...
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Ferdinand de Baecque

Ferdinanddb

a day ago

9.53ms

89.24kb

use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            // other variants...
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

kosay

sarub0b0

a day ago

3.84ms

89.24kb

// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl std::error::Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

kosay

sarub0b0

a day ago

4.10ms

91.89kb

// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl std::error::Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        dbg!(csv_row);
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|f| !f.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Abdulla Faraz

n3m6

a day ago

4.07ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error::Error;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().filter(|x| !x.trim().is_empty()).ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|x| !x.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|x| !x.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Habu

habu1010

2 days ago

5.17ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error::Error;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().filter(|x| !x.trim().is_empty()).ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|x| !x.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|x| !x.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

doroshtapgh

2 days ago

8.98ms

89.24kb

use std::fmt;
// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds
}
// 2. Implement the Error trait for ParseError
impl std::error::Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid")
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.trim().to_string();
        if name.is_empty() {
            return Err(ParseError::NoName);
        }
        let good_deeds = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?
            .trim();
        if good_deeds.is_empty() {
            return Err(ParseError::NoGoodDeeds);
        }
        let good_deeds = good_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?
            .trim();
        if bad_deeds.is_empty() {
            return Err(ParseError::NoBadDeeds);
        }
        let bad_deeds = bad_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Masayuki Sunahara

tamanishi

2 days ago

4.99ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error::Error;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Ankit Kumar Jha

Ankit8848

2 days ago

4.82ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Emmanuel Guefif

eguefif

2 days ago

3.67ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let error_message = match self {
            ParseError::NoName => "Name field is missing",
            ParseError::NoGoodDeeds => "Good deeds field is missing",
            ParseError::NoBadDeeds => "Bad deeds field is missing",
            ParseError::InvalidGoodDeeds => "Good deeds value is invalid",
            ParseError::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", error_message)
    }
}
impl Error for ParseError {}
// 2. Implement the Error trait for ParseError
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name.trim().len() == 0 {
            return Err(ParseError::NoName);
        }
        let mut good_deeds = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?;
        if good_deeds.len() == 0 {
            return Err(ParseError::NoGoodDeeds);
        }
        let good_deeds = good_deeds.parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?;
         if bad_deeds.len() == 0 {
            return Err(ParseError::NoBadDeeds);
        }
        let bad_deeds = bad_deeds.parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Kushneryk Pavel

KushnerykPavel

2 days ago

4.30ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| {!s.trim().is_empty()})
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Rickard Jensen

rjensen

2 days ago

4.01ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt::{Display, Formatter};
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NoName => write!(f, "Name field is missing"),
            Self::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            Self::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            Self::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            Self::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Rounak Sen

rony0000013

2 days ago

4.68ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error::Error;
use::std::fmt::{Display, Formatter};
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
      }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

pagyeman

2 days ago

5.73ms

89.24kb

// Import the necessary modules
use::std::{error::Error, fmt::{Display, Formatter}};
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        use ParseError::*;
        match self {
            NoName => write!(f, "Name field is missing"),
            NoGoodDeeds => write!(f, "Good deeds field is missing"),
            NoBadDeeds => write!(f, "Bad deeds field is missing"),
            InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Sukrit Amornpornwiwat

arm01846

3 days ago

4.75ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error::Error;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name.is_empty() {
            return Err(ParseError::NoName);
        }
        let good_deeds = fields.next();
        if let Some("") = good_deeds {
            return Err(ParseError::NoGoodDeeds)
        }
        let good_deeds = good_deeds
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields.next();
        if let Some("") = bad_deeds {
            return Err(ParseError::NoBadDeeds)
        }
        let bad_deeds = bad_deeds
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

gmvar

3 days ago

5.10ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
// 2. Implement the Error trait for ParseError
impl error::Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string(); 
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>().map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>().map_err(|_| ParseError::InvalidBadDeeds)?;    
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Nikita Smirnov

Nismirno

3 days ago

4.22ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = match fields.next().ok_or(ParseError::NoName) {
            Ok(r) => {
                if r.trim().len() == 0 {
                    return Err(ParseError::NoName);
                }
                r.to_string()
            }
            Err(e) => return Err(e),
        };
        let good_deeds = match fields
            .next()
            .ok_or(ParseError::NoGoodDeeds) {
                Ok(r) => {
                    if r.trim().len() == 0 {
                        return Err(ParseError::NoGoodDeeds);
                    }
                    r.parse::<u32>()
                    .map_err(|_| ParseError::InvalidGoodDeeds)?
                }
                Err(e) => return Err(e),
            };
        let bad_deeds = match fields
            .next()
            .ok_or(ParseError::NoBadDeeds) {
                Ok(r) => {
                    if r.trim().len() == 0 {
                        return Err(ParseError::NoBadDeeds);
                    }
            r.parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?
                }
                Err(e) => return Err(e),
        };
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

gsspdev

3 days ago

6.49ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error::Error;
// creates ParseError enum for error handling
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds
}
// implements Display trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid")
        }
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
        // .filter(|a| !a.trim().is_empty())
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string(); 
        let good_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>().map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>().map_err(|_| ParseError::InvalidBadDeeds)?;    
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

hafihaf123

3 days ago

4.34ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::fmt::{Display, Formatter};
use std::error::Error;
use ParseError::*;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl ParseError {
    pub fn as_str(&self) -> &'static str {
        // tidy-alphabetical-start
        match *self {
            NoName => "Name field is missing",
            NoGoodDeeds => "Good deeds field is missing",
            NoBadDeeds => "Bad deeds field is missing",
            InvalidGoodDeeds => "Good deeds value is invalid",
            InvalidBadDeeds => "Bad deeds value is invalid",
        }
    }
}
impl Display for ParseError {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
        fmt.write_str(self.as_str())
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = parse_field(fields.next(), NoName)?.to_string();
        let good_deeds = parse_field(fields.next(), NoGoodDeeds)?;
        let good_deeds = good_deeds
            .parse::<u32>()
            .map_err(|_| InvalidGoodDeeds)?;
        
        let bad_deeds = parse_field(fields.next(), NoBadDeeds)?;
        let bad_deeds = bad_deeds
            .parse::<u32>()
            .map_err(|_| InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
fn parse_field<'a>(field: Option<&'a str>, error: ParseError) -> Result<&'a str, ParseError> {
    field
        .map(|f| f.trim())
        .filter(|f| !f.is_empty())
        .ok_or(error)
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

hafihaf123

3 days ago

6.20ms

90.58kb

// Import the necessary modules
use std::fmt;
use std::fmt::{Display, Formatter};
use std::error::Error;
use ParseError::*;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl ParseError {
    pub fn as_str(&self) -> &'static str {
        // tidy-alphabetical-start
        match *self {
            NoName => "Name field is missing",
            NoGoodDeeds => "Good deeds field is missing",
            NoBadDeeds => "Bad deeds field is missing",
            InvalidGoodDeeds => "Good deeds value is invalid",
            InvalidBadDeeds => "Bad deeds value is invalid",
        }
    }
}
impl Display for ParseError {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
        fmt.write_str(self.as_str())
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = parse_field(fields.next(), NoName)?;
        let good_deeds = parse_field(fields.next(), NoGoodDeeds)?;
        let good_deeds = good_deeds
            .parse::<u32>()
            .map_err(|_| InvalidGoodDeeds)?;
        
        let bad_deeds = parse_field(fields.next(), NoBadDeeds)?;
        let bad_deeds = bad_deeds
            .parse::<u32>()
            .map_err(|_| InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
fn parse_field(field: Option<&str>, error: ParseError) -> Result<String, ParseError> {
    field
        .map(|f| f.to_string())
        .filter(|f| !f.is_empty())
        .ok_or(error)
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

stanisgo

3 days ago

4.31ms

89.24kb

// Import the necessary modules
use std::fmt;
use std::error::Error;
#[derive(Debug)]
pub enum ParseError {    
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .map(|filed| filed.trim())
            .filter(|filed| !filed.is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .map(|filed| filed.trim())
            .filter(|filed| !filed.is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .map(|filed| filed.trim())
            .filter(|filed| !filed.is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Burnus

3 days ago

4.23ms

89.24kb

use std::error::Error;
use std::fmt::{Display, Formatter};
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NoName => write!(f, "Name field is missing"),
            Self::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            Self::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            Self::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            Self::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name.is_empty() {
            return Err(ParseError::NoName);
        }
        let good_deeds = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?;
        if good_deeds.is_empty() {
            return Err(ParseError::NoGoodDeeds);
        }  
        let good_deeds = good_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?;
        if bad_deeds.is_empty() {
            return Err(ParseError::NoBadDeeds);
        }  
        let bad_deeds = bad_deeds
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

vaclav0411

3 days ago

4.64ms

89.24kb

use std::fmt::Display;
use std::error::Error;
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Error for ParseError {}
impl Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().filter(|s| !s.trim().is_empty()).ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Joanne Muthoni

joanne-cmd

3 days ago

3.91ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt::Display;
// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Felipe Ribeiro Saruhashi

felipesaruhashi

4 days ago

4.03ms

89.24kb

use std::error::Error;
use std::fmt::Display;
// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

KLcpb

4 days ago

4.60ms

89.24kb

// Import the necessary modules
// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let error_msg = match self {
            Self::NoName => "Name field is missing",
            Self::NoGoodDeeds => "Good deeds field is missing",
            Self::NoBadDeeds => "Bad deeds field is missing",
            Self::InvalidGoodDeeds => "Good deeds value is invalid",
            Self::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", error_msg)
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

joshvon44

4 days ago

4.77ms

89.24kb

use std::error::Error;
use std::fmt::Display;
// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|a| !a.trim().is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

wishkus

4 days ago

4.61ms

89.24kb

use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let error_msg = match self {
            Self::NoName => "Name field is missing",
            Self::NoGoodDeeds => "Good deeds field is missing",
            Self::NoBadDeeds => "Bad deeds field is missing",
            Self::InvalidGoodDeeds => "Good deeds value is invalid",
            Self::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", error_msg)
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Kanak Shilledar

kanakshilledar

5 days ago

4.28ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let error_msg = match self {
            Self::NoName => "Name field is missing",
            Self::NoGoodDeeds => "Good deeds field is missing",
            Self::NoBadDeeds => "Bad deeds field is missing",
            Self::InvalidGoodDeeds => "Good deeds value is invalid",
            Self::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", error_msg)
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Luis Linares

lulingar

5 days ago

4.24ms

89.24kb

// Import the necessary modules
use std::{
    error::Error,
    fmt,
};
#[derive(Debug)]
pub enum ParseError {   
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NoName => write!(f, "Name field is missing"),
            Self::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            Self::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            Self::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            Self::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        use ParseError::*;
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(NoName)?.to_string();
        if name.trim().len() == 0 {
            return Err(ParseError::NoName);
        }
        let good_deeds = fields
            .next()
            .ok_or(NoGoodDeeds)?
            .trim()
            .parse::<u32>()
            .map_err(|err| {
                use std::num::IntErrorKind::*;
                match &err.kind() {
                    Empty => ParseError::NoGoodDeeds,
                    _ => ParseError::InvalidGoodDeeds,
                }
            })?;
        let bad_deeds = fields
            .next()
            .ok_or(NoBadDeeds)?
            .trim()
            .parse::<u32>()
            .map_err(|err| {
                use std::num::IntErrorKind::*;
                match &err.kind() {
                    Empty => ParseError::NoBadDeeds,
                    _ => ParseError::InvalidBadDeeds,
                }
            })?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Chris

chriswmann

5 days ago

4.07ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let error_msg = match self {
            Self::NoName => "Name field is missing",
            Self::NoGoodDeeds => "Good deeds field is missing",
            Self::NoBadDeeds => "Bad deeds field is missing",
            Self::InvalidGoodDeeds => "Good deeds value is invalid",
            Self::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", error_msg)
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Chris

chriswmann

5 days ago

7.52ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let error_msg = match self {
            Self::NoName => "Name field is missing",
            Self::NoGoodDeeds => "Good deeds field is missing",
            Self::NoBadDeeds => "Bad deeds field is missing",
            Self::InvalidGoodDeeds => "Good deeds value is invalid",
            Self::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", error_msg)
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.trim().is_empty())
            .ok_or_else(|| ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Sergey Martynov

martynovs

5 days ago

4.41ms

89.24kb


// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { 
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
impl std::error::Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|s| s.trim().len() > 0)
            .ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| s.trim().len() > 0)
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| s.trim().len() > 0)
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Tim Toebrock

titoeb

5 days ago

4.16ms

89.24kb

// Import the necessary modules
use std::error::Error;
#[derive(Debug, std::cmp::PartialEq)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NoName => write!(f, "Name field is missing"),
            Self::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            Self::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            Self::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            Self::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }?;
        Ok(())
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = match fields.next().ok_or(ParseError::NoName)? {
            "" => Err(ParseError::NoName),
            name => Ok(name),
        }?
        .to_string();
        let good_deeds = match fields.next().ok_or(ParseError::NoGoodDeeds)? {
            "" => Err(ParseError::NoGoodDeeds),
            good_deed => good_deed
                .parse::<u32>()
                .map_err(|_| ParseError::InvalidGoodDeeds),
        }?;
        let bad_deeds = match fields.next().ok_or(ParseError::NoBadDeeds)? {
            "" => Err(ParseError::NoBadDeeds),
            bad_deed => bad_deed
                .parse::<u32>()
                .map_err(|_| ParseError::InvalidBadDeeds),
        }?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}
#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn no_good_deed() {
        assert_eq!(
            Kid::parse_row("Alice,,1").err().unwrap(),
            ParseError::NoGoodDeeds
        )
    }
    #[test]
    fn no_name() {
        assert_eq!(Kid::parse_row(",1,1").err().unwrap(), ParseError::NoName)
    }
    #[test]
    fn no_bad_deed() {
        assert_eq!(
            Kid::parse_row("Alice,1,").err().unwrap(),
            ParseError::NoBadDeeds
        )
    }
}

Will LaBranche

wlabranche

5 days ago

6.31ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt;
use std::fmt::{ Display, Formatter };
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        let error_message = match self {
            ParseError::NoName => "Name field is missing",
            ParseError::NoGoodDeeds => "Good deeds field is missing",
            ParseError::NoBadDeeds => "Bad deeds field is missing",
            ParseError::InvalidGoodDeeds => "Good deeds value is invalid",
            ParseError::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", error_message)
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
            
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Richmond Steele

RedNapPanda

5 days ago

3.70ms

89.24kb

// Import the necessary modules
use std::error::Error;
use std::fmt::{Display, Formatter};
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        let s = match self {
            ParseError::NoName => "Name field is missing",
            ParseError::NoGoodDeeds => "Good deeds field is missing",
            ParseError::NoBadDeeds => "Bad deeds field is missing",
            ParseError::InvalidGoodDeeds => "Good deeds value is invalid",
            ParseError::InvalidBadDeeds => "Bad deeds value is invalid",
        };
        write!(f, "{}", s)
    }
}
// 2. Implement the Error trait for ParseError
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().filter(|s| !s.is_empty()).ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next()
            .filter(|s| !s.is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|s| !s.is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Guilherme Cesário Strachan

strachan

5 days ago

4.51ms

89.24kb

// Import the necessary modules
use std::fmt;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
// 2. Implement the Error trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid")
        }
    }
}
impl std::error::Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next()
        .filter(|name| !name.is_empty()).ok_or(ParseError::NoName)?.to_string();
        let good_deeds = fields
            .next().filter(|deeds| !deeds.is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next().filter(|deeds| !deeds.is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

sweet2honey

5 days ago

3.93ms

89.24kb

    use std::fmt;
    // Import the necessary modules
    #[derive(Debug, PartialEq)]
    pub enum ParseError {
        // 1. Add variants here (read description)
        NoName,
        NoGoodDeeds,
        NoBadDeeds,
        InvalidGoodDeeds,
        InvalidBadDeeds,
    }
    
    // 2. Implement the Error trait for ParseError
    impl fmt::Display for ParseError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                ParseError::NoName => write!(f, "Name field is missing"),
                ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
                ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
                ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
                ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
            }
        }
    }
    
    
    impl std::error::Error for ParseError { }
    
    
    #[derive(Debug, PartialEq)]
    pub struct Kid {
        pub name: String,
        pub niceness: Niceness,
    }
    
    impl Kid {
        pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
            let niceness = if Self::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            };
    
            Kid { name, niceness }
        }
    
        pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
            // 3. Update the code to return meaningful errors
            let mut fields = csv_row.split(',');
            let name = fields.next()
                .and_then(|x| if x.trim().is_empty() { None } else {Some(x.trim())})
                .ok_or(ParseError::NoName)?
                .to_string();
    
            let good_deeds = fields
                .next()
                .and_then(|x| if x.trim().is_empty() { None } else {Some(x.trim())})
                .ok_or(ParseError::NoGoodDeeds)?
                .parse::<u32>()
                .map_err(|_| ParseError::InvalidGoodDeeds)?;
            let bad_deeds = fields
                .next()
                .and_then(|x| if x.trim().is_empty() { None } else {Some(x.trim())})
                .ok_or(ParseError::NoBadDeeds)?
                .parse::<u32>()
                .map_err(|_| ParseError::InvalidBadDeeds)?;
    
            Ok(Kid::new(name, good_deeds, bad_deeds))
        }
    
        pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
            if good_deeds == 0 && bad_deeds == 0 {
                return false;
            }
    
            let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
            let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
    
            let ratio = good_deeds / (good_deeds + bad_deeds);
    
            ratio >= 0.75
        }
    }
    
    pub const GOOD_WEIGHT: f32 = 1.0;
    pub const BAD_WEIGHT: f32 = 2.0;
    
    #[derive(Debug, PartialEq)]
    pub enum Niceness {
        Nice(u32),
        Naughty,
    }

Wendy Kong

wendko

5 days ago

4.39ms

89.24kb

    use std::fmt;
    // Import the necessary modules
    #[derive(Debug, PartialEq)]
    pub enum ParseError {
        // 1. Add variants here (read description)
        NoName,
        NoGoodDeeds,
        NoBadDeeds,
        InvalidGoodDeeds,
        InvalidBadDeeds,
    }
    
    // 2. Implement the Error trait for ParseError
    impl fmt::Display for ParseError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                ParseError::NoName => write!(f, "Name field is missing"),
                ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
                ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
                ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
                ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
            }
        }
    }
    
    
    impl std::error::Error for ParseError { }
    
    
    #[derive(Debug, PartialEq)]
    pub struct Kid {
        pub name: String,
        pub niceness: Niceness,
    }
    
    impl Kid {
        pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
            let niceness = if Self::is_nice(good_deeds, bad_deeds) {
                Niceness::Nice(good_deeds)
            } else {
                Niceness::Naughty
            };
    
            Kid { name, niceness }
        }
    
        pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
            // 3. Update the code to return meaningful errors
            let mut fields = csv_row.split(',');
            let name = fields.next()
                .and_then(|x| if x.trim().is_empty() { None } else {Some(x.trim())})
                .ok_or(ParseError::NoName)?
                .to_string();
    
            let good_deeds = fields
                .next()
                .and_then(|x| if x.trim().is_empty() { None } else {Some(x.trim())})
                .ok_or(ParseError::NoGoodDeeds)?
                .parse::<u32>()
                .map_err(|_| ParseError::InvalidGoodDeeds)?;
            let bad_deeds = fields
                .next()
                .and_then(|x| if x.trim().is_empty() { None } else {Some(x.trim())})
                .ok_or(ParseError::NoBadDeeds)?
                .parse::<u32>()
                .map_err(|_| ParseError::InvalidBadDeeds)?;
    
            Ok(Kid::new(name, good_deeds, bad_deeds))
        }
    
        pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
            if good_deeds == 0 && bad_deeds == 0 {
                return false;
            }
    
            let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
            let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
    
            let ratio = good_deeds / (good_deeds + bad_deeds);
    
            ratio >= 0.75
        }
    }
    
    pub const GOOD_WEIGHT: f32 = 1.0;
    pub const BAD_WEIGHT: f32 = 2.0;
    
    #[derive(Debug, PartialEq)]
    pub enum Niceness {
        Nice(u32),
        Naughty,
    }

Stephan Lindner

Stephan-Lindner

5 days ago

4.07ms

89.24kb

use std::error::Error;
use std::fmt::{Display, Formatter};
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Error for ParseError {}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
        use ParseError::*;
        write!(f, "{}", match self {
            NoName => "Name field is missing",
            NoGoodDeeds => "Good deeds field is missing",
            NoBadDeeds => "Bad deeds field is missing",
            InvalidGoodDeeds => "Good deeds value is invalid",
            InvalidBadDeeds => "Bad deeds value is invalid",
        })
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Stephan Lindner

Stephan-Lindner

5 days ago

4.91ms

89.24kb

use std::error::Error;
use std::fmt::{Display, Formatter};
#[derive(Debug)]
pub enum ParseError {
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Error for ParseError {}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
        use ParseError::*;
        write!(f, "{}", match self {
            NoName => "Name field is missing",
            NoGoodDeeds => "Good deeds field is missing",
            NoBadDeeds => "Bad deeds field is missing",
            InvalidGoodDeeds => "Good deeds value is invalid",
            InvalidBadDeeds => "Bad deeds value is invalid",
        })
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoName)?
            .to_string();
        if name.is_empty() {
            return Err(ParseError::NoName)
        }
        let good_deeds = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .filter(|field| !field.is_empty())
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Dominic

DominicD

5 days ago

4.93ms

89.24kb

use std::error::Error;
use std::fmt::Display;
use std::fmt::Formatter;
// Import the necessary modules
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl ParseError {
    pub fn as_str(&self) -> &'static str {
        use ParseError::*;
        match *self {
            NoName => "Name field is missing",
            NoGoodDeeds => "Good deeds field is missing",
            NoBadDeeds => "Bad deeds field is missing",
            InvalidGoodDeeds => "Good deeds value is invalid",
            InvalidBadDeeds => "Bad deeds value is invalid"
        }
    }
}
impl Display for ParseError{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result
    {
        f.write_str(self.as_str())
    }
}
impl Error for ParseError{}
// 2. Implement the Error trait for ParseError
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name.trim().is_empty()
        {
            return Err(ParseError::NoName);
        }
        let good_deeds = fields
            .next()
            .and_then(|good_deeds| {
                let trimmed = good_deeds.trim();
                if trimmed.is_empty() {
                    None
                } else {
                   Some(trimmed)
                }
            })
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds = fields
            .next()
            .and_then(|bad_deeds| {
                let trimmed = bad_deeds.trim();
                if trimmed.is_empty() {
                    None
                } else {
                   Some(trimmed)
                }
            })
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

jsdm13

5 days ago

4.30ms

89.24kb

use std::fmt;
use std::error::Error;
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds
}
// 2. Implement the Error trait for ParseError
impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid")
        }
    }
}
impl Error for ParseError {}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields
            .next()
            .and_then(|name| {
                let trimmed = name.trim();
                if trimmed.is_empty() {
                    None
                } else {
                   Some(trimmed)
                }
            })
            .ok_or(ParseError::NoName)?
            .to_string();
        let good_deeds = fields
            .next()
            .and_then(|good_deeds| {
                let trimmed = good_deeds.trim();
                if trimmed.is_empty() {
                    None
                } else {
                   Some(trimmed)
                }
            })
            .ok_or(ParseError::NoGoodDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        
        let bad_deeds = fields
            .next()
            .and_then(|bad_deeds| {
                let trimmed = bad_deeds.trim();
                if trimmed.is_empty() {
                    None
                } else {
                   Some(trimmed)
                }
            })
            .ok_or(ParseError::NoBadDeeds)?
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}

Aaron Seilis

seilis

5 days ago

5.15ms

89.24kb

// Import the necessary modules
use std::fmt::{Display, Formatter};
#[derive(Debug)]
pub enum ParseError {
    // 1. Add variants here (read description)
    NoName,
    NoGoodDeeds,
    NoBadDeeds,
    InvalidGoodDeeds,
    InvalidBadDeeds,
}
impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
        match self {
            ParseError::NoName => write!(f, "Name field is missing"),
            ParseError::NoGoodDeeds => write!(f, "Good deeds field is missing"),
            ParseError::NoBadDeeds => write!(f, "Bad deeds field is missing"),
            ParseError::InvalidGoodDeeds => write!(f, "Good deeds value is invalid"),
            ParseError::InvalidBadDeeds => write!(f, "Bad deeds value is invalid"),
        }
    }
}
pub struct Kid {
    pub name: String,
    pub niceness: Niceness,
}
impl Kid {
    pub fn new(name: String, good_deeds: u32, bad_deeds: u32) -> Kid {
        let niceness = if Self::is_nice(good_deeds, bad_deeds) {
            Niceness::Nice(good_deeds)
        } else {
            Niceness::Naughty
        };
        Kid { name, niceness }
    }
    pub fn parse_row(csv_row: &str) -> Result<Kid, ParseError> {
        // 3. Update the code to return meaningful errors
        let mut fields = csv_row.split(',');
        let name = fields.next().ok_or(ParseError::NoName)?.to_string();
        if name.len() == 0 {
            return Err(ParseError::NoName);
        }
        let good_deeds_raw = fields
            .next()
            .ok_or(ParseError::NoGoodDeeds)?;
        if good_deeds_raw.len() == 0 {
            return Err(ParseError::NoGoodDeeds);
        }
        let good_deeds = good_deeds_raw
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidGoodDeeds)?;
        let bad_deeds_raw = fields
            .next()
            .ok_or(ParseError::NoBadDeeds)?;
        
        if bad_deeds_raw.len() == 0 {
            return Err(ParseError::NoBadDeeds);
        }
        let bad_deeds = bad_deeds_raw
            .parse::<u32>()
            .map_err(|_| ParseError::InvalidBadDeeds)?;
        Ok(Kid::new(name, good_deeds, bad_deeds))
    }
    pub fn is_nice(good_deeds: u32, bad_deeds: u32) -> bool {
        if good_deeds == 0 && bad_deeds == 0 {
            return false;
        }
        let good_deeds = good_deeds as f32 * GOOD_WEIGHT;
        let bad_deeds = bad_deeds as f32 * BAD_WEIGHT;
        let ratio = good_deeds / (good_deeds + bad_deeds);
        ratio >= 0.75
    }
}
pub const GOOD_WEIGHT: f32 = 1.0;
pub const BAD_WEIGHT: f32 = 2.0;
#[derive(Debug, PartialEq)]
pub enum Niceness {
    Nice(u32),
    Naughty,
}