Rust Tutorial : File Input/ Output
from tutorialspoint.com

Commonly Used Methods

Module Method Signature Description
std::fs::File open() pub fn open<P: AsRef>(path: P) -> Result the open static method can be used to open a file in read-only mode
std::fs::File create() pub fn create<P: AsRef>(path: P) -> Result static method opens a file in write-only mode
if the file already existed, the old content is destroyed
otherwise a new file is created
std::fs::remove_file remove_file() pub fn remove_file<P: AsRef>(path: P) -> Result<()> removes a file from the filesystem
there is no guarantee that the file will be immediately deleted
std::fs::OpenOptions append() pub fn append(&mut self, append: bool) -> &mut OpenOptions sets the option for the append mode of file
std::io::Writes write_all() fn write_all(&mut self, buf: &[u8]) -> Result<()> attempts to write an entire buffer into this write
std::io::Read read_to_string() fn read_to_string(&mut self, buf: &mut String) -> Result reads all bytes until EOF in this source, appending them to buf

Write to a File
the following program creates a file 'data.txt'
the create() method is used to create a file
the method returns a file handle if the file is created successfully
the last line write_all function will write bytes in newly created file
if any of the operations fail, the expect() function returns an error message 
use std::io::Write;
fn main() {
   let mut file = std::fs::File::create("data.txt").expect("create failed");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("data written to file" );
}
Read from a File
the following program reads the contents in a file data.txt and prints it to the console
the open() function is used to open an existing file
an absolute or relative path to the file is passed to the open() function as a parameter
the open() function throws an exception if the file does not exist, or if it is not accessible for whatever reason
if it succeeds, a file handle to such file is assigned to the 'file' variable
the read_to_string() function of the 'file' handle is used to read contents of that file into a string variable 
use std::io::Read;

fn main(){
   let mut file = std::fs::File::open("data.txt").unwrap();
   let mut contents = String::new();
   file.read_to_string(&mut contents).unwrap();
   print!("{}", contents);
}
Delete a file
example uses the remove_file() function to delete a file
the expect() function returns a custom message in case an error occurs 
use std::fs;
fn main() {
   fs::remove_file("data.txt").expect("could not remove file");
   println!("file is removed");
}
Append data to a file
the append() function writes data to the end of the file 
use std::fs::OpenOptions;
use std::io::Write;

fn main() {
   let mut file = OpenOptions::new().append(true).open("data.txt").expect("cannot open file");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("file append success");
}
Copy a file
example copies the contents in a file to a new file 
use std::io::Read;
use std::io::Write;

fn main() {
   let mut command_line: std::env::Args = std::env::args();
   command_line.next().unwrap();
   // skip the executable file name
   // accept the source file
   let source = command_line.next().unwrap();
   // accept the destination file
   let destination = command_line.next().unwrap();
   let mut file_in = std::fs::File::open(source).unwrap();
   let mut file_out = std::fs::File::create(destination).unwrap();
   let mut buffer = [0u8; 4096];
   loop {
      let nbytes = file_in.read(&mut buffer).unwrap();
      file_out.write(&buffer[..nbytes]).unwrap();
      if nbytes < buffer.len() { break; }
   }
}
to run app 
main.exe <source file> <destination file>
index