Completed functions and added comments. Rustfmt.

hw6/task1/src/main.rs

@@ -10,27 +10,25 @@ use nix::unistd::ForkResult::{Child, Parent};
 
 fn main() {
 
- let arguments: Vec<String> = args().collect();
+    let arguments: Vec<String> = args().collect();
 
-    if arguments.len() != 0 {
-   
+    if arguments.len() > 2 {
 
-    let pid = fork();
-    match pid {
-        Ok(Child) => {
-            println!("hello, I am child (pid:{})", getpid());
-        }
 
-        Ok(Parent { child }) => {
-            if let Ok(ws) = wait() {
-                if let WaitStatus::Exited(child_pid, exit_code) = ws {
-                
+        let pid = fork();
+        match pid {
+            Ok(Child) => {
+                println!("hello, I am child (pid:{})", getpid());
+            }
+
+            Ok(Parent { child }) => {
+                if let Ok(ws) = wait() {
+                    if let WaitStatus::Exited(child_pid, exit_code) = ws {}
                 }
             }
-        }
 
-        Err(_) => {}
-    }
+            Err(_) => {}
+        }
 
 
 
@@ -42,17 +40,38 @@ fn main() {
 }
 
 /// Concats the two given String *references* and returns them as a String.
-fn concatenate_strings<'a>(s1:&'a str, s2:&'a str) -> String {
+fn concatenate_strings<'a>(s1: &'a str, s2: &'a str) -> String {
     s1.to_string() + s2
 }
 
-/// Splits the given String *reference* and returns it as Vector of Strings.
-fn split_into_strings<'a>(s1:&'a str) -> Vec<String> {
+/// Splits the given String reference and returns it as Vector.
+/*fn split_into_strings<'2>(s1:&'a str) -> Vec<&'a str> {
     s1.to_string().split_whitespace().collect()
+}*/
+/// Calculates the sum of the given Strings and returns them as a Result.
+fn sum_strings(v: Vec<&str>) -> Result<i32, &str> {
+    let mut sum = 0;
+    for x in v {
+        match x.parse::<i32>() {
+            Ok(val) => {
+                sum += val;
+            }
+            Err(_) => return Err("Given String is not a int"),
+        }
+    }
+    Ok(sum)
 }
 
-fn sum_strings(){
-}
-
-fn mul_strings(){
+/// Calculates the product of the given Strings and returns them as a Result.
+fn mul_strings(v: Vec<&str>) -> Result<i32, &str> {
+    let mut prod = 0;
+    for x in v {
+        match x.parse::<i32>() {
+            Ok(val) => {
+                prod *= val;
+            }
+            Err(_) => return Err("Given String is not a int"),
+        }
+    }
+    Ok(prod)
 }