I recently finished chapter 8 of Rust's book, and below is my solution to the third exercise. I'd appreciate pointers on how the code can be improved. Thanks in advance.

use std::collections::HashMap;
//An attempt at Rust book's chapter 8's third exercise:
//https://doc.rust-lang.org/book/ch08-03-hash-maps.html
fn main() {
 println!("The Office - Text Interface.");
 println!();
 println!("Enter a query, type HELP for a list of keyword and their functions, or type EXIT to exit.");
 println!();
 //build hashmap{department: vec[names]} database, insert default values
 let mut company = HashMap::new();
 
 let depts = vec!["SALES", "ENGINEERING", "HR", "SANITATION"];
 let sales = vec!["Sally", "Jordan", "Charlie", "Abigail"];
 let engineering = vec!["Suzy", "Jay", "Chi", "Amy"];
 let hr = vec!["Son", "Jack", "Chia", "Anna"];
 let sanitation = vec!["August", "Entangle", "Will", "Jada"];
 let tup = [sales, engineering, hr, sanitation];
 let mut g: Vec<_> = Vec::new();
 company = depts.into_iter()
 .map(|x| x.to_string())
 .zip(tup.iter().map(|y| {g = y.iter().map(|q| q.to_string()).collect(); g.clone()}))
 .collect();
 let keywords = ["ADD", "LIST", "UPDATE", "REMOVE", "HELP", "EXIT"];
 // loop the input part of the text interface.
 //validate first keyword, send queries to functions.
 loop {
 let mut query = String::new();
 println!("::");
 //check for empty input
 io::stdin().read_line(&mut query).expect("Enter a valid input");
 query = query.trim().to_string();
 // println!("{}", query);
 if query.is_empty() {
 println!("Invalid input. Type HELP for a keyword reference.");
 continue;
 }
 //check for valid first keyword
 let keyword = query.split_whitespace().next().unwrap().to_uppercase();
 if !keywords.contains(&&keyword[..]) {
 println!("Invalid Keyword. Type HELP for a keyword reference.");
 continue;
 }
 //keyword validated. Call the function.
 let mut query = query.split_whitespace().collect::<Vec<_>>();
 match &&keyword[..] {
 &"EXIT" => return,
 &"HELP" => help(),
 &"ADD" => add(&mut query, &mut company),
 &"LIST" => list(&mut query, &mut company),
 &"UPDATE" => update(&mut query, &mut company),
 &"REMOVE" => remove(&mut query, &mut company),
 _ => (),
 }
 // println!("{:?}", company); //debug purposes: print the entire hashmap on each loop to monitor changes.
 continue;
 }
}
fn add(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 //validate add syntax
 let length = q.len();
 if length < 3 || length > 4 {
 println!("Invalid ADD syntax. Type HELP for a keyword reference.");
 return;
 }
 //add a new department
 if length == 3 {
 match (q[0], q[1], q[2]) {
 ("ADD", "-D", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if company.contains_key(&dept) {
 println!("Department {} already exists.", d);
 return;
 }
 //add dept
 company.entry(dept).or_insert(Vec::new());
 println!("Created department {}.", d);
 return;
 }
 _ => {
 println!("Invalid syntax.");
 return;
 }
 }
 }
 //add a person to a department
 if length == 4 {
 match (q[0], q[1], q[2], q[3]) {
 ("ADD", name, "TO", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //check if name already exists in dept
 if company[&dept].contains(&name.to_owned()) {
 println!("The name {} already exists in {}.", name, dept);
 return;
 }
 //add name to vector
 (*company.get_mut(&dept).unwrap()).push(name.to_owned());
 println!("Added {} to {}.", name, d);
 }
 _ => {
 println!("Invalid Syntax");
 return;
 }
 }
 }
}
fn list(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 //sanitize input
 let length = q.len();
 if length != 2 && length !=4 {
 println!("Invalid number of arguments.");
 return;
 }
 if length == 2 {
 match (q[0], q[1]) {
 //list all depts
 ("LIST", "-D") => {
 let mut depts: Vec<_> = company.keys().collect();
 depts.sort();
 for d in depts {
 println!("{}", d);
 }
 return;
 }
 //list everyone in all depts, sorted alphabetically
 ("LIST", "-E") => {
 for (dept, mut names) in company.clone() {
 println!("---{}---", dept);
 names.sort();
 for name in names {
 println!("{}", name);
 }
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
 }
 if length == 4 {
 match (q[0], q[1], q[2], q[3]) {
 ("LIST", "-E", "IN", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //list all in department
 println!("---{}---", dept);
 (*company.get_mut(&dept).unwrap()).sort();
 for name in &company[&dept] {
 println!("{}", name);
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
 }
}
fn update(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 let length = q.len();
 if length != 5 && length != 6 {
 println!("Invalid UPDATE syntax.");
 return;
 }
 if length == 5 {
 match (q[0], q[1], q[2], q[3], q[4]) {
 //update a department
 ("UPDATE", "-D", old_d, "TO", new_d) => {
 //check if dept exists
 let old_dept = old_d.to_uppercase();
 let new_dept = new_d.to_uppercase();
 if !company.contains_key(&old_dept) {
 println!("Department {} does not exist.", old_d);
 return;
 }
 if company.contains_key(&new_dept) {
 println!("Department {} already exists.", new_d);
 return;
 }
 //rename dept. Technique is to build a new vector with that same name since you
 //cannot change the key of a hash map.
 let temp_dept = company.get(&old_dept).unwrap().clone();
 company.insert(new_dept.to_uppercase(), temp_dept);
 company.remove(&old_dept);
 println!("Changed Department {} to {}.", old_d, new_d);
 return;
 }
 _ => {
 println!("Invalid syntax.");
 return;
 }
 }
 }
 //change a name in a department
 match (q[0], q[1], q[2], q[3], q[4], q[5]) {
 ("UPDATE", old_name, "FROM", d, "TO", new_name) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //check if old name and new name exist
 if !company[&dept].contains(&old_name.to_owned()) {
 println!("The name {} does not exist in {}.", old_name, dept);
 return;
 }
 if company[&dept].contains(&new_name.to_owned()) {
 println!("The name {} already exists in {}.", new_name, dept);
 return;
 }
 //update the name.
 for (i, name) in company[&dept].clone().iter().enumerate() {
 if name == old_name {
 (*company.get_mut(&dept).unwrap())[i] = new_name.to_owned();
 println!("Changed {} in {} to {}.", old_name, dept, new_name);
 return;
 }
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
}
fn remove(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 let length = q.len();
 if length !=3 && length !=4 {
 println!("Invalid REMOVE syntax.");
 return;
 }
 if length == 3 {
 match (q[0], q[1], q[2]) {
 ("REMOVE", "-D", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //remove the department.
 company.remove(&dept);
 println!("Removed department {}.", d);
 return;
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
 }
 //remove a person
 match (q[0], q[1], q[2], q[3]) {
 ("REMOVE", name, "FROM", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //check if name exists
 if !company[&dept].contains(&name.to_owned()) {
 println!("The name {} does not exist in {}.", name, dept);
 return;
 }
 //remove the name
 for (i, _name) in company[&dept].clone().iter().enumerate() {
 if _name == name {
 (*company.get_mut(&dept).unwrap()).remove(i);
 println!("Removed {} from {}.", name, dept);
 return;
 }
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
}
fn help() {
 println!("The Office - KEYWORD HELP");
 println!();
 println!("Note: All keywords are case-sensitive.");
 println!("Keywords: \nLIST - Lists items in the database");
 println!("Usage: LIST -E - Lists all employees");
 println!(" LIST -E IN [DEPARTMENT] - Lists all employees in specified department.");
 println!(" LIST -D - Lists all departmnets in the company");
 println!();
 println!("ADD - Adds items to the database.");
 println!("Usage: ADD [name] TO [department] - Adds the name to the specified department.");
 println!(" ADD -D [department] - Adds the department to the roster.");
 println!();
 println!("REMOVE - Removes items from the database.");
 println!(" REMOVE -D [department] - Removes the particular department from the database.");
 println!(" REMOVE [name] FROM [department] - Removes the person from the specified department.");
 println!();
 println!("UPDATE - Changes records in the database.");
 println!("Usage: UPDATE -D [old name] TO [new name] - Changes a department's name.");
 println!(" UPDATE [old name] FROM [department] TO [new name] - Changes a person's name.");
 println!();
 println!("HELP - Prints this help screen.");
 println!();
 println!("EXIT - Exits the program.")
}

I recently finished chapter 8 of Rust's book, and below is my solution to the third exercise :

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.

I'd appreciate pointers on how the code can be improved. Thanks in advance.

use std::io;
use std::collections::HashMap;
//An attempt at Rust book's chapter 8's third exercise:
//https://doc.rust-lang.org/book/ch08-03-hash-maps.html
fn main() {
 println!("The Office - Text Interface.");
 println!();
 println!("Enter a query, type HELP for a list of keyword and their functions, or type EXIT to exit.");
 println!();
 //build hashmap{department: vec[names]} database, insert default values
 let mut company = HashMap::new();
 
 let depts = vec!["SALES", "ENGINEERING", "HR", "SANITATION"];
 let sales = vec!["Sally", "Jordan", "Charlie", "Abigail"];
 let engineering = vec!["Suzy", "Jay", "Chi", "Amy"];
 let hr = vec!["Son", "Jack", "Chia", "Anna"];
 let sanitation = vec!["August", "Entangle", "Will", "Jada"];
 let tup = [sales, engineering, hr, sanitation];
 let mut g: Vec<_> = Vec::new();
 company = depts.into_iter()
 .map(|x| x.to_string())
 .zip(tup.iter().map(|y| {g = y.iter().map(|q| q.to_string()).collect(); g.clone()}))
 .collect();
 let keywords = ["ADD", "LIST", "UPDATE", "REMOVE", "HELP", "EXIT"];
 // loop the input part of the text interface.
 //validate first keyword, send queries to functions.
 loop {
 let mut query = String::new();
 println!("::");
 //check for empty input
 io::stdin().read_line(&mut query).expect("Enter a valid input");
 query = query.trim().to_string();
 // println!("{}", query);
 if query.is_empty() {
 println!("Invalid input. Type HELP for a keyword reference.");
 continue;
 }
 //check for valid first keyword
 let keyword = query.split_whitespace().next().unwrap().to_uppercase();
 if !keywords.contains(&&keyword[..]) {
 println!("Invalid Keyword. Type HELP for a keyword reference.");
 continue;
 }
 //keyword validated. Call the function.
 let mut query = query.split_whitespace().collect::<Vec<_>>();
 match &&keyword[..] {
 &"EXIT" => return,
 &"HELP" => help(),
 &"ADD" => add(&mut query, &mut company),
 &"LIST" => list(&mut query, &mut company),
 &"UPDATE" => update(&mut query, &mut company),
 &"REMOVE" => remove(&mut query, &mut company),
 _ => (),
 }
 // println!("{:?}", company); //debug purposes: print the entire hashmap on each loop to monitor changes.
 continue;
 }
}
fn add(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 //validate add syntax
 let length = q.len();
 if length < 3 || length > 4 {
 println!("Invalid ADD syntax. Type HELP for a keyword reference.");
 return;
 }
 //add a new department
 if length == 3 {
 match (q[0], q[1], q[2]) {
 ("ADD", "-D", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if company.contains_key(&dept) {
 println!("Department {} already exists.", d);
 return;
 }
 //add dept
 company.entry(dept).or_insert(Vec::new());
 println!("Created department {}.", d);
 return;
 }
 _ => {
 println!("Invalid syntax.");
 return;
 }
 }
 }
 //add a person to a department
 if length == 4 {
 match (q[0], q[1], q[2], q[3]) {
 ("ADD", name, "TO", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //check if name already exists in dept
 if company[&dept].contains(&name.to_owned()) {
 println!("The name {} already exists in {}.", name, dept);
 return;
 }
 //add name to vector
 (*company.get_mut(&dept).unwrap()).push(name.to_owned());
 println!("Added {} to {}.", name, d);
 }
 _ => {
 println!("Invalid Syntax");
 return;
 }
 }
 }
}
fn list(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 //sanitize input
 let length = q.len();
 if length != 2 && length !=4 {
 println!("Invalid number of arguments.");
 return;
 }
 if length == 2 {
 match (q[0], q[1]) {
 //list all depts
 ("LIST", "-D") => {
 let mut depts: Vec<_> = company.keys().collect();
 depts.sort();
 for d in depts {
 println!("{}", d);
 }
 return;
 }
 //list everyone in all depts, sorted alphabetically
 ("LIST", "-E") => {
 for (dept, mut names) in company.clone() {
 println!("---{}---", dept);
 names.sort();
 for name in names {
 println!("{}", name);
 }
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
 }
 if length == 4 {
 match (q[0], q[1], q[2], q[3]) {
 ("LIST", "-E", "IN", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //list all in department
 println!("---{}---", dept);
 (*company.get_mut(&dept).unwrap()).sort();
 for name in &company[&dept] {
 println!("{}", name);
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
 }
}
fn update(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 let length = q.len();
 if length != 5 && length != 6 {
 println!("Invalid UPDATE syntax.");
 return;
 }
 if length == 5 {
 match (q[0], q[1], q[2], q[3], q[4]) {
 //update a department
 ("UPDATE", "-D", old_d, "TO", new_d) => {
 //check if dept exists
 let old_dept = old_d.to_uppercase();
 let new_dept = new_d.to_uppercase();
 if !company.contains_key(&old_dept) {
 println!("Department {} does not exist.", old_d);
 return;
 }
 if company.contains_key(&new_dept) {
 println!("Department {} already exists.", new_d);
 return;
 }
 //rename dept. Technique is to build a new vector with that same name since you
 //cannot change the key of a hash map.
 let temp_dept = company.get(&old_dept).unwrap().clone();
 company.insert(new_dept.to_uppercase(), temp_dept);
 company.remove(&old_dept);
 println!("Changed Department {} to {}.", old_d, new_d);
 return;
 }
 _ => {
 println!("Invalid syntax.");
 return;
 }
 }
 }
 //change a name in a department
 match (q[0], q[1], q[2], q[3], q[4], q[5]) {
 ("UPDATE", old_name, "FROM", d, "TO", new_name) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //check if old name and new name exist
 if !company[&dept].contains(&old_name.to_owned()) {
 println!("The name {} does not exist in {}.", old_name, dept);
 return;
 }
 if company[&dept].contains(&new_name.to_owned()) {
 println!("The name {} already exists in {}.", new_name, dept);
 return;
 }
 //update the name.
 for (i, name) in company[&dept].clone().iter().enumerate() {
 if name == old_name {
 (*company.get_mut(&dept).unwrap())[i] = new_name.to_owned();
 println!("Changed {} in {} to {}.", old_name, dept, new_name);
 return;
 }
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
}
fn remove(q: &mut Vec<&str>, company: &mut HashMap<String, Vec<String>>) {
 let length = q.len();
 if length !=3 && length !=4 {
 println!("Invalid REMOVE syntax.");
 return;
 }
 if length == 3 {
 match (q[0], q[1], q[2]) {
 ("REMOVE", "-D", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //remove the department.
 company.remove(&dept);
 println!("Removed department {}.", d);
 return;
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
 }
 //remove a person
 match (q[0], q[1], q[2], q[3]) {
 ("REMOVE", name, "FROM", d) => {
 //check if dept exists
 let dept = d.to_uppercase();
 if !company.contains_key(&dept) {
 println!("Department {} does not exist.", d);
 return;
 }
 //check if name exists
 if !company[&dept].contains(&name.to_owned()) {
 println!("The name {} does not exist in {}.", name, dept);
 return;
 }
 //remove the name
 for (i, _name) in company[&dept].clone().iter().enumerate() {
 if _name == name {
 (*company.get_mut(&dept).unwrap()).remove(i);
 println!("Removed {} from {}.", name, dept);
 return;
 }
 }
 }
 _ => {
 println!("Invalid Syntax.");
 return;
 }
 }
}
fn help() {
 println!("The Office - KEYWORD HELP");
 println!();
 println!("Note: All keywords are case-sensitive.");
 println!("Keywords: \nLIST - Lists items in the database");
 println!("Usage: LIST -E - Lists all employees");
 println!(" LIST -E IN [DEPARTMENT] - Lists all employees in specified department.");
 println!(" LIST -D - Lists all departmnets in the company");
 println!();
 println!("ADD - Adds items to the database.");
 println!("Usage: ADD [name] TO [department] - Adds the name to the specified department.");
 println!(" ADD -D [department] - Adds the department to the roster.");
 println!();
 println!("REMOVE - Removes items from the database.");
 println!(" REMOVE -D [department] - Removes the particular department from the database.");
 println!(" REMOVE [name] FROM [department] - Removes the person from the specified department.");
 println!();
 println!("UPDATE - Changes records in the database.");
 println!("Usage: UPDATE -D [old name] TO [new name] - Changes a department's name.");
 println!(" UPDATE [old name] FROM [department] TO [new name] - Changes a person's name.");
 println!();
 println!("HELP - Prints this help screen.");
 println!();
 println!("EXIT - Exits the program.")
}