Added a non working shell error type

hw7/task2/src/errortype.rs

+#[derive(Debug, PartialEq)]
+pub enum ErrorType {
+    PathError,
+    BrokenPipeError,
+    ForkError,
+}

hw7/task2/src/lib.rs

 use nix::sys::wait::{wait, waitpid, WaitStatus};
 use nix::unistd::{dup2, close, execvp, fork, pipe, read, write};
 
-mod shellerror;
+mod errortype;
 
-use shellerror::ShellError;
+use errortype::ErrorType;
 
 #[derive(PartialEq, Debug)]
 pub enum Command {
 }
 
 impl FromStr for Command {
-    type Err = ShellError;
+    type Err = ErrorType;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
 
         let mut parts = s.split_whitespace();
     }
     /// Initializes the Shell Loop.
     /// Starts the shell.
-    pub fn start(&mut self) -> Result<(), &str> {
+    pub fn start(&mut self) -> Result<(), ErrorType> {
         self.shell_loop()
     }
 
     /// Loops while exit hasn't been called.
     /// When *prompt()* returns (the user hit enter) a Command is created through the FromStr-Trait.
     /// If the Command-creation succeeds, run the command.
-    fn shell_loop(&mut self) -> Result<(), &str> {
+    fn shell_loop(&mut self) -> Result<(), ErrorType> {
         while !self.should_exit {
             if let Ok(Some(line)) = self.prompt() {
                 let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
 
     /// Prints the shell prompt.
     /// Waits for user input and returns the read line.
-    pub fn prompt(&mut self) -> Result<Option<String>, &str> {
+    pub fn prompt(&mut self) -> Result<Option<String>, ErrorType> {
         match env::current_dir() {
             Ok(pwd) => {
                 let _ = self.writer.write(
                     Err(_) => Ok(None),
                 }
             }
-            Err(_) => return Err("Path Error"),
+            Err(_) => return Err(ErrorType::PathError),
         }
     }
 
     /// Runs a command.
     /// Currently only `cd` and `exit` are working.
-    fn run(&mut self, command: Command) -> Result<(), ShellError> {
+    fn run(&mut self, command: Command) -> Result<(), ErrorType> {
 
         match command {
             Command::Empty => {},
                                     Ok(Parent { child }) => {
                                         wait();
                                         if let Some(second) = commands_vec.get(1) {
-                                            close(writer).unwrap();
+                                            match close(writer) {
+                                                Ok(_) => {},
+                                                Err(_) => return Err(ErrorType::BrokenPipeError),
+                                            }
                                             dup2(reader, 0).unwrap();
                                             self.execute(second);
                                         }
                                             self.execute(first);
                                         }
                                     }
-                                    Err(_) => println!("Fatal error: Fork failed"),
+                                    Err(_) => return Err(ErrorType::ForkError),
                                 }
                             }
                         }
-                        Err(_) => println!("Fatal error: Fork failed"),
+                        Err(_) => return Err(ErrorType::ForkError),
                     }
 
             },

hw7/task2/src/shellerror.rs

-#[derive(PartialEq, Debug)]
-pub struct ShellError;