Fixup.

hw6/task2/src/command.rs

 use std::ffi::OsString;
 use std::str::FromStr;
 use std::env;
-use std::path::Path;
 
 pub enum Command {
     Empty,
 pub struct CommandNotFoundError;
 
 impl FromStr for Command {
-
     type Err = CommandNotFoundError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
 
         let mut parts = s.split_whitespace();
 
         match parts.next() {
-            Some("exit") => return Ok(Command::Exit),
-            Some("cd") => return Ok(Command::parse_cd(parts.next())),
-            Some(_) => return Ok(Command::Empty),
-            None => return Err(CommandNotFoundError),
+            Some("exit") => {
+                Ok(Command::Exit)
+            },
+            Some("cd") => {
+                Ok(Command::parse_cd(parts.next()))
+            },
+            Some(cmd) => {
+                //For use in next homework, to execute programs.
+                let _ = cmd;
+                Err(CommandNotFoundError)
+            },
+            None => {
+                Ok(Command::Empty)
+            },
         }
     }
 
 }
 
+
 impl Command {
+
     pub fn parse_cd(cmd: Option<&str>) -> Self {
         match cmd {
             None => Command::Cd(None),
 
     pub fn exec_cd(&self) {
         if let Command::Cd(None) = *self  {
-            let home = env::home_dir().unwrap();
-            let home_path = home.as_path();
-            env::set_current_dir(home_path);
+            let possible_home = env::home_dir();
+
+            if let Some(home) = possible_home {
+                let home_path = home.as_path();
+                let _ = env::set_current_dir(home_path);
+            }
+
         }
 
         if let Command::Cd(Some(ref path)) = *self {
             match path.to_str() {
-                Some(_) => {env::set_current_dir(path);},
+                Some(_) => {
+                    let _ = env::set_current_dir(path);
+                },
                 None => {},
             }
 

hw6/task2/src/shell.rs

     }
 
     /// Waits for user inputs.
-    fn shell_loop(&mut self) -> Result<(),&str> {
+    fn shell_loop(&mut self) -> Result<(), &str> {
         while !self.should_exit {
             if let Ok(line) = self.prompt() {
-                Command::from_str(&line).and_then(|cmd| self.run(cmd));
+                let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
             }
         }
         Ok(())
 
         match env::current_dir() {
             Ok(pwd) => {
-                self.writer.write(format!("{} {} > ", self.name, pwd.display()).as_bytes());
-                self.writer.flush();
+                let _ = self.writer.write(format!("{} {} > ", self.name, pwd.display()).as_bytes());
+                let _ = self.writer.flush();
 
                 let mut line: String = String::new();
                 let read_result = self.reader.read_line(&mut line);
     fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError>{
 
         match command {
-            Command::Empty => {
-                self.writer.write("Command not found\n".as_bytes());
-                self.writer.flush();
-                return Err(CommandNotFoundError);},
+            Command::Empty => {},
             Command::Exit => self.should_exit = true,
             Command::Cd(_) => {
                 command.exec_cd();