Follow these steps:

1. Open the Cargo.toml file that was generated earlier for you.

2. Under [dependencies], add the following line:

    flate2 = "0.2.20"

   If you want, you can go to flate2's crates.io page (https://crates.io/crates/flate2) to check for the newest version and use that one instead.

3. In the bin folder, create a file called compression.rs.

4. Add the following code and run it with cargo run --bin compression:

1    extern crate flate2;
2 
3    use std::io::{self, SeekFrom};
4    use std::io::prelude::*;
5 
6    use flate2::{Compression, FlateReadExt};
7    use flate2::write::ZlibEncoder;
8    use flate2::read::ZlibDecoder;
9 
10   use std::fs::{File, OpenOptions};
11   use std::io::{BufReader, BufWriter, Read};
12 
13   fn main() {
14     let bytes = b"I have a dream that one day this nation will
         rise up, 
15     and live out the true meaning of its creed";
16     println!("Original: {:?}", bytes.as_ref());
17     // Conpress some bytes
18     let encoded = encode_bytes(bytes.as_ref()).expect("Failed to
         encode bytes");
19     println!("Encoded: {:?}", encoded);
20     // Decompress them again
21     let decoded = decode_bytes(&encoded).expect("Failed to decode
         bytes");
22     println!("Decoded: {:?}", decoded);
23 
24     // Open file to compress
25     let original = File::open("ferris.png").expect("Failed to
         open file");
26     let mut original_reader = BufReader::new(original);
27 
28     // Compress it
29     let data = encode_file(&mut original_reader).expect("Failed
         to encode file");
30 
31     // Write compressed file to disk
32     let encoded = OpenOptions::new()
33       .read(true)
34       .write(true)
35       .create(true)
36       .open("ferris_encoded.zlib")
37       .expect("Failed to create encoded file");
38     let mut encoded_reader = BufReader::new(&encoded);
39     let mut encoded_writer = BufWriter::new(&encoded);
40     encoded_writer
41       .write_all(&data)
42       .expect("Failed to write encoded file");
43 
44 
45     // Jump back to the beginning of the compressed file
46     encoded_reader
47       .seek(SeekFrom::Start(0))
48       .expect("Failed to reset file");
49 
50     // Decompress it
51     let data = decode_file(&mut encoded_reader).expect("Failed to
         decode file");
52 
53     // Write the decompressed file to disk
54     let mut decoded =
         File::create("ferris_decoded.png").expect("Failed to create
           decoded file");
55     decoded
56       .write_all(&data)
57       .expect("Failed to write decoded file");
58   }

5. These are the functions doing the actual encoding and decoding:

61   fn encode_bytes(bytes: &[u8]) -> io::Result<Vec<u8>> {
62     // You can choose your compression algorithm and it's
         efficiency
63     let mut encoder = ZlibEncoder::new(Vec::new(),
         Compression::Default);
64     encoder.write_all(bytes)?;
65     encoder.finish()
66   }
67 
68   fn decode_bytes(bytes: &[u8]) -> io::Result<Vec<u8>> {
69     let mut encoder = ZlibDecoder::new(bytes);
70     let mut buffer = Vec::new();
71     encoder.read_to_end(&mut buffer)?;
72     Ok(buffer)
73   }
74 
75 
76   fn encode_file(file: &mut Read) -> io::Result<Vec<u8>> {
77     // Files have a built-in encoder
78     let mut encoded = file.zlib_encode(Compression::Best);
79     let mut buffer = Vec::new();
80     encoded.read_to_end(&mut buffer)?;
81     Ok(buffer)
82   }
83 
84   fn decode_file(file: &mut Read) -> io::Result<Vec<u8>> {
85     let mut buffer = Vec::new();
86     // Files have a built-in decoder
87     file.zlib_decode().read_to_end(&mut buffer)?;
88     Ok(buffer)
89   }