Den of Uniquity

Copy the book’s 06_uniqr/tests directory into your project, and then run cargo test to ensure that the program compiles and the tests run and fail.

Defining the Arguments

Update your src/main.rs to the following:

fn main() {
    if let Err(e) = uniqr::get_args().and_then(uniqr::run) {
        eprintln!("{}", e);
        std::process::exit(1);
    }
}



I suggest you start src/lib.rs with the following:

use clap::{App, Arg};
use std::error::Error;

type MyResult<T> = Result<T, Box<dyn Error>>;

#[derive(Debug)]
pub struct Config {
    in_file: String, 
    out_file: Option<String>, 
    count: bool, 
}


This is the input filename to read, which may be STDIN if the filename is a dash.

The output will be written either to an optional output filename or STDOUT.

count is a Boolean for whether or not to print the counts of each line.


Here is an outline for get_args:


pub fn get_args() -> MyResult<Config> {
    let matches = App::new("uniqr")
        .version("0.1.0")
        .author("Ken Youens-Clark <kyclark@gmail.com>")
        .about("Rust uniq")
        // What goes here?
        .get_matches();

    Ok(Config {
        in_file: ...
        out_file: ...
        count: ...
    })
}


I suggest you start your run by printing the config:


pub fn run(config: Config) -> MyResult<()> {
    println!("{:?}", config);
    Ok(())
}


Your program should be able to produce the following usage:


$ cargo run -- -h
uniqr 0.1.0
Ken Youens-Clark <kyclark@gmail.com>
Rust uniq

USAGE:
    uniqr [FLAGS] [ARGS]

FLAGS:
    -c, --count      Show counts 
    -h, --help       Prints help information
    -V, --version    Prints version information

ARGS:
    <IN_FILE>     Input file [default: -] 
    <OUT_FILE>    Output file 


The -c|--count flag is optional.

The input file is the first positional argument and defaults to a dash (-).

The output file is the second positional argument and is optional.


By default the program will read from STDIN, which can be represented using a dash:


$ cargo run
Config { in_file: "-", out_file: None, count: false }

The first positional argument should be interpreted as the input file and the second positional argument as the output file.1
Note that clap can handle options either before or after positional arguments:

$ cargo run -- tests/inputs/one.txt out --count
Config { in_file: "tests/inputs/one.txt", out_file: Some("out"), count: true }
Note
Take a moment to finish get_args before reading further.


I assume you are an upright and moral person who figured out the preceding function on your own, so I will now share my solution:


pub fn get_args() -> MyResult<Config> {
    let matches = App::new("uniq")
        .version("0.1.0")
        .author("Ken Youens-Clark <kyclark@gmail.com>")
        .about("Rust uniq")
        .arg(
            Arg::with_name("in_file")
                .value_name("IN_FILE")
                .help("Input file")
                .default_value("-"),
        )
        .arg(
            Arg::with_name("out_file")
                .value_name("OUT_FILE")
                .help("Output file"),
        )
        .arg(
            Arg::with_name("count")
                .short("c")
                .help("Show counts")
                .long("count")
                .takes_value(false),
        )
        .get_matches();

    Ok(Config {
        in_file: matches.value_of_lossy("in_file").unwrap().to_string(), 
        out_file: matches.value_of("out_file").map(String::from), 
        count: matches.is_present("count"), 
    })
}


Convert the in_file argument to a String.

Convert the out_file argument to an Option<String>.

The count is either present or not, so convert this to a bool.


Because the in_file argument has a default value, it is safe to call Option::unwrap and convert the value to a String.
There are several other ways to get the same result, none of which is necessarily superior.
You could use Option::map to feed the value to String::from and then unwrap it:

    in_file: matches.value_of_lossy("in_file").map(String::from).unwrap(),


You could also use a closure that calls Into::into to convert the value into a String because Rust can infer the type:

    in_file: matches.value_of_lossy("in_file").map(|v| v.into()).unwrap(),


The preceding can also be expressed using the Into::into function directly because functions are first-class values that can be passed as arguments:

    in_file: matches.value_of_lossy("in_file").map(Into::into).unwrap(),


The out_file is optional, but if there is an option, you can use Option::map to convert a Some value to a String:

    out_file: matches.value_of("out_file").map(|v| v.to_string()),


Variable Lifetimes
You may wonder why I don’t leave in_file as a &str value.
Consider what would happen if I did this:


#[derive(Debug)]
pub struct Config {
    in_file: &str,
    out_file: Option<&str>,
    count: bool,
}

pub fn get_args() -> MyResult<Config> {
    let matches = App::new("uniq")
        ...

    Ok(Config {
        in_file: matches.value_of("in_file").unwrap(),
        out_file: matches.value_of("out_file"),
        count: matches.is_present("count"),
    })
}

The compiler would complain about missing lifetime specifiers:


error[E0106]: missing lifetime specifier
  --> src/lib.rs:11:14
   |
11 |     in_file: &str,
   |              ^ expected named lifetime parameter
   |
help: consider introducing a named lifetime parameter
   |
10 | pub struct Config<'a> {
11 |     in_file: &'a str,

The lifetime refers to how long a value is valid for borrowing throughout a program.
The problem here is that I’m trying to take references to values from matches, which goes out of scope at the end of the function and is then dropped.
Returning a Config that stores references to a dropped value would lead to dangling pointers, which is not allowed.
In the next section I’ll demonstrate a practical use of lifetimes; for a deeper discussion of lifetimes, I would refer you to other texts, such as Programming Rust or other more comprehensive books.
In this instance, the only valid choice is to return a dynamic, heap-allocated String.

Defining the Arguments

Note

Testing the Program

Processing the Input Files

Note

Note

Chapter 6. Den of Uniquity

How uniq Works

Getting Started

Solution

Going Further

Summary