https://doc.rust-lang.org/book/ch08-03-hash-maps.html

Using a hash map and vectors, create a text interface to allow a user to add employee names to a department in a company. For example, “Add Sally to Engineering” or “Add Amir to Sales.” Then let the user retrieve a list of all people in a department or all people in the company by department, sorted alphabetically.

This language, its book and the community are just straight up awesome. I had a quick read of other reviews just before posting mine, and I decided it'd be a good idea to run cargo fmt and cargo clippy before posting. +1 for tooling!

There's two drivers for me posting this- firstly, is the data structure I'm using ok?

HashMap<String, Vec<String>>

It feels a little... strange. Because a HashMap is re-sizeable, Strings are re-sizeable and Vecs are re-sizeable. Is this safe and/or efficient? Am I overthinking?

Secondly, I've attempted to handle as many error cases as I can but I wonder whether there's any that I've missed? Can't wait to get to the automated testing chapter, where I can start to maybe tackle those problems. Anyway, without further ado:

// valid commands:
// ADD name TO department, DEL name FROM department
// LIST department, LIST, QUIT
use std::{
    collections::HashMap,
    {io, io::Write},
};

#[derive(Debug)]
struct Command {
    c_type: CommandType,
    args: Option<Vec<String>>,
}

#[derive(Debug)]
enum CommandType {
    Add,
    List,
    Del,
    Quit,
}

impl CommandType {
    fn new(val: String) -> Option<CommandType> {
        match val.as_str() {
            "ADD" => Some(CommandType::Add),
            "DEL" => Some(CommandType::Del),
            "LIST" => Some(CommandType::List),
            "QUIT" => Some(CommandType::Quit),
            _ => None,
        }
    }
}

fn main() {
    let mut employer_table: HashMap<String, Vec<String>> = HashMap::new();

    employer_table.insert(
        String::from("ENGINEERING"),
        vec![
            String::from("Lewis"),
            String::from("Ellen"),
            String::from("Alan"),
        ],
    );

    employer_table.insert(
        String::from("SALES"),
        vec![
            String::from("Jane"),
            String::from("Robert"),
            String::from("Penny"),
        ],
    );

    loop {
        let cmd: String = match user_prompt() {
            Ok(val) => val,
            _ => {
                println!("Bad user input. Please try again...");
                continue;
            }
        };

        let cmd: Command = match command_parser(cmd) {
            Some(val) => val,
            None => {
                println!("Invalid command... Please type ADD, DEL, LIST or QUIT.");
                continue;
            }
        };

        // QUIT is the only command that returns false
        if !command_executor(cmd, &mut employer_table) {
            break;
        }
    }
}

fn user_prompt() -> io::Result<String> {
    let mut buf = String::new();
    let stdin = io::stdin();

    // This is a little prompt to indicate that a terminal row is typable...
    // Copied this guide on SO to get this prompt working:
    // https://stackoverflow.com/a/41387232
    print!("> ");
    io::stdout().flush().unwrap();
    stdin.read_line(&mut buf)?;

    Ok(String::from(buf.trim())) // Remove trailing CRLF, convert str to String
}

// valid commands:
// ADD name TO department, DEL name FROM department
// LIST department, LIST, QUIT
fn command_parser(c: String) -> Option<Command> {
    let args: Vec<&str> = c.split(' ').collect(); // Convert string to array of words
    let arg0 = args[0].to_uppercase();

    match CommandType::new(arg0) {
        Some(c_type) => {
            let mut args = slice_vec_to_string_vec(args);

            if !args.is_empty()  {
                let len = args.len() - 1;
                args[len] = args[len].to_uppercase();
                Some(Command {c_type, args: Some(args) })
            } else {
                Some(Command { c_type, args: None })
            }
        }
        None => None,
    }
}

fn slice_vec_to_string_vec(s: Vec<&str>) -> Vec<String> {
    let mut tmp: Vec<String> = Vec::new();

    for i in s[1..].iter() {
        tmp.push(String::from(*i));
    }

    tmp
}

fn command_executor(cmd: Command, table: &mut HashMap<String, Vec<String>>) -> bool {
    match cmd.c_type {
        CommandType::Add => {
            match cmd.args {
                Some(arg) => {
                    add_employee(table, String::from(&arg[0][..]), String::from(&arg[2][..]))
                }
                None => println!("Invalid arguments..."),
            }
            true
        }
        CommandType::List => {
            match cmd.args {
                Some(arg) => list_all_employees(table, Some(String::from(&arg[0]))),
                None => list_all_employees(table, None),
            }
            true
        }
        CommandType::Del => {
            match cmd.args {
                Some(arg) => {
                    del_employee(table, String::from(&arg[0][..]), String::from(&arg[2][..]))
                }
                None => println!("Invalid arguments..."),
            }
            true
        }
        CommandType::Quit => {
            println!("Thank you for using this shitty system. Goodbye!");
            false
        }
    }
}

fn list_all_employees(table: &HashMap<String, Vec<String>>, opts: Option<String>) {
    match opts {
        Some(opt) => match table.get(&opt) {
            Some(values) => println!("\n{}: {:#?}", opt, values),
            None => println!("{} is an invalid department.", opt),
        },
        None => println!("{:#?}", table),
    }
}

fn add_employee(table: &mut HashMap<String, Vec<String>>, emp: String, dep: String) {
    match table.get_mut(&dep) {
        Some(ptr) => ptr.push(emp),
        None => println!(
            "Failed to get a pointer to the department: {} using employee: {}",
            dep, emp
        ),
    };
}

fn del_employee(table: &mut HashMap<String, Vec<String>>, emp: String, dep: String) {
    match table.get_mut(&dep) {
        Some(d_ptr) => match d_ptr.iter().position(|e| *e == emp) {
            Some(e_ptr) => {
                d_ptr.remove(e_ptr); // Has to have semi colon so that the arm doesn't return anything
            }
            None => println!("Unable to remove that element..."),
        },
        None => println!(
            "Failed to get a pointer to department: {} using employee: {}",
            dep, emp
        ),
    };
}
```