Rustfmt.

hw6/task1/src/main.rs

 use nix::unistd::ForkResult::{Child, Parent};
 use std::os::unix::io::RawFd;
 
-const BUFFER_SIZE : usize = 256;
+const BUFFER_SIZE: usize = 256;
 
 
 fn main() {
     let arguments: Vec<String> = args().collect();
 
     if arguments.len() > 2 {
-        if let Ok((reader, writer)) = pipe(){
+        if let Ok((reader, writer)) = pipe() {
             let numbers = arguments[1..].to_vec();
 
             let pid = fork();
             match pid {
                 Ok(Child) => {
-
                     match read_from_pipe(reader) {
                         Ok(msg_received) => {
                             let vec = split_into_strings(&msg_received);
                                         Ok(res) => println!("Sum = {}", res),
                                         Err(e) => println!("{}", e),
                                     }
-                                },
-                                Ok(Parent{..}) => {
+                                }
+                                Ok(Parent { .. }) => {
                                     if let Ok(ws) = wait() {
-                                        if let WaitStatus::Exited(_,_) = ws {
+                                        if let WaitStatus::Exited(_, _) = ws {
                                             match mul_strings(vec) {
                                                 Ok(res) => println!("Mul = {}", res),
                                                 Err(e) => println!("{}", e),
                                             }
                                         }
                                     }
-                                },
+                                }
                                 Err(_) => println!("Fatal error: Fork failed"),
                             }
 
-                        },
-                        Err(_) => {},
+                        }
+                        Err(_) => {}
                     }
-
-
                 }
 
-                Ok(Parent{..}) => {
+                Ok(Parent { .. }) => {
                     let mut args = String::new();
                     for s in numbers {
-                        args = concatenate_strings(&args, &concatenate_strings(&s , " "));
+                        args = concatenate_strings(&args, &concatenate_strings(&s, " "));
                     }
                     println!("sending to children: {}", args);
-                    if let Err(_) = write(writer, args.as_bytes()) { println!("Broken pipe") }
+                    if let Err(_) = write(writer, args.as_bytes()) {
+                        println!("Broken pipe")
+                    }
 
                     if let Err(_) = wait() {
                         println!("Waiting on children failed")
 
 }
 
-fn read_from_pipe(reader:RawFd) -> Result<String, String>{
+fn read_from_pipe(reader: RawFd) -> Result<String, String> {
     let mut read_buf = [0u8; BUFFER_SIZE];
-    match read(reader, &mut read_buf){
+    match read(reader, &mut read_buf) {
         Ok(bytes_read) => {
-            match str::from_utf8(&read_buf[0 .. bytes_read]) {
+            match str::from_utf8(&read_buf[0..bytes_read]) {
                 Ok(msg_received) => Ok(msg_received.to_string()),
                 Err(_) => Err("Couldn't read".to_string()),
             }
-        },
+        }
         Err(_) => Err("Couldn't read".to_string()),
     }
 }
         }
     }
     Ok(prod)
-}
+}

hw6/task2/src/command.rs

         let mut parts = s.split_whitespace();
 
         match parts.next() {
-            Some("exit") => {
-                Ok(Command::Exit)
-            },
-            Some("cd") => {
-                Ok(Command::parse_cd(parts.next()))
-            },
+            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)
-            },
+            }
+            None => Ok(Command::Empty),
         }
     }
-
 }
 
 
 impl Command {
-
     /// If the passed String exists, set the path of the Cd in the enum
     pub fn parse_cd(cmd: Option<&str>) -> Self {
         match cmd {
     }
 
     pub fn exec_cd(&self) {
-        if let Command::Cd(None) = *self  {
+        if let Command::Cd(None) = *self {
             let possible_home = env::home_dir();
 
             if let Some(home) = possible_home {
             match path.to_str() {
                 Some(_) => {
                     let _ = env::set_current_dir(path);
-                },
-                None => {},
+                }
+                None => {}
             }
 
         }

hw6/task2/src/shell.rs

-use std::io::{BufRead,Write,Read, StdinLock, StdoutLock};
+use std::io::{BufRead, Write, Read, StdinLock, StdoutLock};
 use std::io;
 
 use command::*;
     pub name: String,
 }
 
-impl <'a> Shell<R<'a>, W<'a>> {
+impl<'a> Shell<R<'a>, W<'a>> {
     /// Creates a new Shell with a name, input and output.
     pub fn new(input: R<'a>, output: W<'a>, name: String) -> Self {
         Shell {
-            reader : input,
-            writer : output,
-            should_exit : false,
-            name : name,
+            reader: input,
+            writer: output,
+            should_exit: false,
+            name: name,
         }
     }
     /// Initializes the Shell Loop.
 
     /// Prints the shell prompt.
     /// Waits for user input and returns the read line.
-    fn prompt (&mut self) -> Result<String, &str> {
+    fn prompt(&mut self) -> Result<String, &str> {
         match env::current_dir() {
             Ok(pwd) => {
-                let _ = self.writer.write(format!("{} {} > ", self.name, pwd.display()).as_bytes());
+                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);
                 match read_result {
-                    Ok(_) => {
-                        Ok(line)
-                    },
-                    Err(_) => {
-                        Err("Error reading.")
-                    },
+                    Ok(_) => Ok(line),
+                    Err(_) => Err("Error reading."),
                 }
-            },
+            }
             Err(_) => return Err("Path Error"),
         }
     }
 
     /// Runs a command.
     /// Currently only `cd` and `exit` are working.
-    fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError>{
+    fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError> {
 
         match command {
-            Command::Empty => {},
+            Command::Empty => {}
             Command::Exit => self.should_exit = true,
             Command::Cd(_) => {
                 command.exec_cd();
-            },
+            }
         }
         Ok(())
     }
-
 }
 
 /// Implement Read-Trait for Tuple-Struct R
 /// Simply calls `read` of StdinLock
-impl <'a>Read for R<'a> {
+impl<'a> Read for R<'a> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
         self.0.read(buf)
     }
 
 /// Implement BufRead-Trait for Tuple-Struct R
 /// Simply calls `fill_buff` and `consume` from StdinLock
-impl <'a>BufRead for R<'a> {
+impl<'a> BufRead for R<'a> {
     fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
         self.0.fill_buf()
     }
 
 /// Implement Write-Trait for Tuple-Struct W
 /// Simply calls `write` and `flush` from StdoutLock
-impl <'a>Write for W<'a> {
+impl<'a> Write for W<'a> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
         self.0.write(buf)
     }
 
-    fn flush(&mut self) -> Result<(),  io::Error> {
+    fn flush(&mut self) -> Result<(), io::Error> {
         self.0.flush()
     }
 }
-