Rust Tutorial : Input/Output
from tutorialspoint.com

Reader and Writer Types
Rust’s standard library features for input and output are organized around two traits
  • read - types which implement Read have methods for byte-oriented input.
  • write - types which implement Write support both byte-oriented and UTF-8 text output
Read Trait
Read() reads a line of text and appends it to line, which is a String
return value is an io::Result, the number of bytes read
syntax 
read_line(&mut line)->Result
readers are components can read bytes from
examples include reading input from the keyboard, files, etc.
the read_line() method of this trait can be used to read data, one line at a time, from a file or standard input stream

apps might have to accept values from the user at runtime
example reads values from the standard input (Keyboard) and prints it to the console 

fn main(){
   let mut line = String::new();
   println!("Enter your name :");
   let b1 = std::io::stdin().read_line(&mut line).unwrap();
   println!("Hello , {}", line);
   println!("no of bytes read , {}", b1);
}
Write Trait
write() method of this trait can be used to write data to a file or standard output stream
writers are components apps can write bytes to
syntax 
write(&buf)->Result
writes some of the bytes in the slice buf to the underlying stream
returns an io::Result, the number of bytes written

The print! or println! macros can be used to display text on the console
can also use the write() standard library function to display some text to the standard output
example 

use std::io::Write;
fn main() {
   let b1 = std::io::stdout().write("Tutorials ".as_bytes()).unwrap();
   let b2 = std::io::stdout().write(String::from("Point").as_bytes()).unwrap();
   std::io::stdout().write(format!("\nbytes written {}",(b1+b2)).as_bytes()).unwrap();
}
the stdout() standard library function returns a handle to the standard output stream of the current process, to which the write function can be applied
write() method returns an enum, Result
unwrap() is a helper method to extract the actual result from the enumeration
unwrap method will send panic if an error occurs
Command Line Arguments
Command Line parameters can be used to pass values to the main() function
the std::env::args() returns the command line arguments example 
// main.rs
fn main(){
   let cmd_line = std::env::args();
   println!("No of elements in arguments is :{}",cmd_line.len()); 
   // print total number of values passed
   for arg in cmd_line {
      println!("[{}]",arg); // print all values passed as commandline arguments
   }
}
example below calculates the sum of values passed as commandline arguments
a list ofinteger values separated by space is passed to program 
fn main(){
   let cmd_line = std::env::args();
   println!("No of elements in arguments is :{}", cmd_line.len()); 
   // total number of elements passed

   let mut sum = 0;
   let mut has_read_first_arg = false;

   // iterate through all the arguments and calculate their sum
   for arg in cmd_line {
      if has_read_first_arg { // skip the first argument since it is the exe file name
         sum += arg.parse::().unwrap();
      }
      has_read_first_arg = true; 
      // set the flag to true to calculate sum for the subsequent arguments.
   }
   println!("sum is {}",sum);
}
index