// I AM NOT DONE

    total / values.len()

    total / values.len() as f64

use std::convert::{TryFrom, TryInto};
use std::error;

use std::{convert::{TryFrom, TryInto}, error, fmt};

// I AM NOT DONE

    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {}

    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {
        Ok(Color {
            red: u8::try_from(tuple.0)?,
            green: u8::try_from(tuple.1)?,
            blue: u8::try_from(tuple.2)?
        })
    }

    fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {}

    fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {
        Ok(Color {
            red: u8::try_from(arr[0])?,
            green: u8::try_from(arr[1])?,
            blue: u8::try_from(arr[2])?
        })
    }

#[derive(Debug, Clone)]
struct IncorrectSliceLength;

impl fmt::Display for IncorrectSliceLength {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Incorrect slice length.")
    }
}
impl error::Error for IncorrectSliceLength {}

    fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {}

    fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {
        if slice.len() == 3 {
            Ok(Color {
                red: u8::try_from(slice[0])?,
                green: u8::try_from(slice[1])?,
                blue: u8::try_from(slice[2])?
            })
        } else { Err(Box::new(IncorrectSliceLength)) }
    }

use std::error;
use std::str::FromStr;

use std::{error, str::FromStr, fmt};

// I AM NOT DONE

#[derive(Debug, Clone)]
struct InvalidInput;
impl fmt::Display for InvalidInput {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Could not parse input.")
    }
}
impl error::Error for InvalidInput {}

        let v: Vec<&str> = s.split(',').collect();
        if v.len() != 2 || v[0].is_empty() {
            Err(Box::new(InvalidInput))
        } else {
            Ok(Person {
                name: v[0].to_string(),
                age: v[1].parse::<usize>()?
            })
        }

// I AM NOT DONE

        let mut s = s.split(',');
        if let (Some(name), Some(age), None) = (s.next(), s.next(), s.next()) {
            if let (false, Ok(age)) = (name.is_empty(), age.parse()) {
                return Person {
                    name: String::from(name),
                    age,
                };
            }
        }
        Person::default()

// I AM NOT DONE

fn byte_counter<T>(arg: T) -> usize {

fn byte_counter<T: AsRef<str>>(arg: T) -> usize {

fn char_counter<T>(arg: T) -> usize {

fn char_counter<T: AsRef<str>>(arg: T) -> usize {