Index

! (exclamation point)
- beginning shebang lines in bash, Creating the Test Output Files
- ending names of macros, Getting Started with “Hello, world!”
- not operator, Getting Started
"" (quotation marks), enclosing names of arguments, How echo Works
#[test] attribute, Writing and Running Integration Tests
$ (dollar sign)
- end of string matching in regular expressions, Defining the Arguments, Using a Regular Expression to Match an Integer with an Optional Sign
$? bash variable, Understanding Program Exit Values
% (percent sign), indicating end of fortune record, Solution
& operator, Opening a File or STDIN
- binary AND, Displaying Octal Permissions
- borrowing reference to a variable, Using the Test Suite
&& (logical and) operator, Exit Values Make Programs Composable, Solution
- combining with || (logical or operator), Solution
() (parentheses)
- capturing in regular expressions, Parsing the Position List
- grouping and capturing in regular expressions, Using a Regular Expression to Match an Integer with an Optional Sign
- grouping find utility arguments, How find Works
- signifying unit type, Getting Started
(.)\1 pattern, finding any character repeated twice, Defining the Arguments
* (asterisk)
- dereference operator, Parsing the Position List
- escaping in bash, How find Works
- matching zero or more occurrences in regular expressions, Defining the Arguments, Defining the Arguments
+ (plus sign)
- before numbers in tail utility, How tail Works
- beginning of file starting position in tailr, Defining the Arguments
- matching in regular expressions, Using a Regular Expression to Match an Integer with an Optional Sign, Using a Regular Expression to Match an Integer with an Optional Sign
+0 starting point in tail, Defining the Arguments
+= (addition and assignment) operator, Printing Line Numbers
- (dash or minus sign)
- - for short names and ‐‐ for long names of arguments, Accessing the Command-Line Arguments
- before numbers in tail utility, How tail Works
- denoting range in character classes in regular expressions, Using a Regular Expression to Match an Integer with an Optional Sign
- filename argument, reading with cat, How cat Works
- input filename in commr, Validating and Opening the Input Files
- matching in regular expressions, Using a Regular Expression to Match an Integer with an Optional Sign
-> symbol, indicating symbolic links, How find Works
. (dot)
- any one character in regular expressions, Defining the Arguments
- file or directory names starting with, How ls Works, Finding the Files
- indicating current directory, Getting Started with “Hello, world!”, How find Works, How grep Works, Defining the Arguments
- placing inside character class [.], Defining the Arguments
// (slashes), comments beginning with, Solution
/// (slashes), to indicate documentation, Solution
::<> (turbofish) operator, Reading Bytes from a File, Defining and Validating the Arguments
; (semicolon), lack of terminating in functions, Using the Result Type
> (redirect) operator in bash, How echo Works, Opening a File or STDIN
? (question mark)
- in regular expressions, Using a Regular Expression to Match an Integer with an Optional Sign
- operator, replacing Result::unwrap with, Using the Result Type
- operator, using to propagate error to main function, Defining the Arguments
[] (square brackets)
- indicating character class, Defining the Arguments
- indicating character classes in regular expressions, Using a Regular Expression to Match an Integer with an Optional Sign
\ (backslash), escaping special characters, How find Works
\1 backreference, Defining the Arguments
\d (digits) in regular expressions, Using a Regular Expression to Match an Integer with an Optional Sign
^ (caret)
- beginning of string matching in regular expressions, Defining the Arguments, Using a Regular Expression to Match an Integer with an Optional Sign
- bit-wise exclusive OR operator, Solution
_ (underscore)
- indicating partial type annotation, Reading Bytes from a File
- various uses in Rust, Reading Bytes from a File
- wildcard character in matching, Opening a File or STDIN
{} (curly braces)
- enclosing body of a function, Getting Started with “Hello, world!”
- serving as placeholder for printed value of literal string, Accessing the Command-Line Arguments
| (pipe) symbol
- piping commands, Writing and Running Integration Tests
- piping STDOUT from first command to STDIN for second command, Opening a File or STDIN
- using to connect STDOUT and STDIN for commands, How cat Works
|| (pipes)
- or operator, Solution
- or operator, combining with && operator, Solution
- || { … } closure form, Solution

date command, Rascalry, Going Further
Date struct, Defining and Validating the Arguments
DateTime struct, Solution
days, Solution
dbg! (debug) macro, Defining the Parameters
delimited text files, parsing, Parsing Delimited Text Files-Parsing Delimited Text Files
delimiters
- changing tab output delimiter in commr, Solution
- comma output delimiter, setting with -d option, Defining the Arguments
- delimiter as u8 byte, Parsing Delimited Text Files
- escaping, How cut Works
- escaping in cutr utility, Final Boss
- tab character, comm output delimiter, How comm Works
- tab character, commr output delimiter, Defining the Arguments
dependencies
- adding clap as dependency, Adding clap as a Dependency
- adding project dependency, Adding a Project Dependency
Deref::deref operator, Parsing the Position List
dereferencing pointers, Using the Result Type
dies (for failing tests), Writing Integration Tests
diff utility, How echo Works
difference, Boston Commons
directories
- directory name without --recursive option rejected in grepr, Finding the Files to Search
- directory names in grep, How grep Works
- metadata::is_dir function, Formatting the Long Listing
- organizing for Rust project, Organizing a Rust Project Directory
- supplying as text source for fortune, How fortune Works
DirEntry, Solution
DirEntry::file_type function, Solution
DirEntry::path, Solution
dirname, Finding the Files
dir_long utility function, Notes from the Testing Underground, Notes from the Testing Underground
Display trait, Accessing the Command-Line Arguments
don’t repeat yourself (DRY) principle, Solution
dotfiles, How ls Works
dyn keyword, Using the Result Type

-E flag for extended regular expressions, Defining the Arguments
-e pattern regular expressions in grep, Defining the Arguments
echo utility, Test for Echo-Summary
- accessing command-line arguments, Accessing the Command-Line Arguments-Accessing the Command-Line Arguments
- creating program output for echor, Creating the Program Output-Creating the Program Output
- how it works, How echo Works
- writing integration tests for echor, Writing Integration Tests-Summary
editions of Rust, Creating and Running a Project with Cargo
else keyword, Creating the Program Output
end of file starting position in tailr, Defining the Arguments
ending variable, Creating the Program Output
entry types
- config.entry_types, Solution
- interpreting for findr, Validating the Arguments
EntryType enum, Defining the Arguments
- Dir, File, or Link, Defining the Arguments
EntryType::File, Solution
enum type, Defining the Arguments
- creating where variants can hold value, Defining the Arguments
- naming conventions in Rust, Defining the Arguments
$env:Path variable (Windows), Writing and Running Integration Tests
environment, interacting with, Accessing the Command-Line Arguments
EOF (end of file), Preserving Line Endings While Reading a File
eprintln! macro, Creating a Library Crate
Error trait, Using the Result Type, Getting Started, Converting Strings into Errors
errors
- converting strings into, Converting Strings into Errors-Defining the Arguments
- error messages for cutr utility, parse_pos function, Defining the Arguments
- find utility searches, How find Works
- handling in finding matching input lines in grepr, Finding the Matching Lines of Input
- incorporating filename in input file error messages for commr, Validating and Opening the Input Files
- invalid file arguments printed to STDERR, Finding the Files to Search
- printing to STDERR for grepr finding matching lines of input, Solution
- printing to STDERR using eprintln!, Creating a Library Crate
- reporting for echor program, Parsing Command-Line Arguments Using clap
- unreadable directories in findr, Finding All the Things
escape sequences created by Style::reverse, Writing the Program
escaping special characters
- asterisk (*) in bash shell, How find Works
- delimiters, How cut Works
executables, Getting Started with “Hello, world!”
exit values (program), Understanding Program Exit Values
- making programs composable, Exit Values Make Programs Composable
expected output versus actual output, Testing the Program Output
expressions versus statements, Creating the Program Output
extended regular expressions, Defining the Arguments
- indicating with -E flag, Defining the Arguments
Extract::Fields, Defining the Arguments
extracting bytes, characters, or fields, Defining the Arguments, Parsing the Position List
- extracting characters or bytes, Extracting Characters or Bytes-Extracting Characters or Bytes

join operations, Boston Commons

-m month option (calr), Defining and Validating the Arguments
-m option (fortune), How fortune Works
-m option (fortuner), Defining the Arguments, Reading the Fortune Files
macOS, find output from BSD version, How find Works
macros, Getting Started with “Hello, world!”
main function, Getting Started with “Hello, world!”
man cat command, How cat Works
man echo command, How echo Works
map, filter, and filter_map operations, chaining for findr, Solution
mask method, Solution
match function, including guard in, Writing a Unit Test to Parse a String into a Number
match keyword, Opening a File or STDIN
-max_depth and -min_depth options (find), Going Further
memory
- reading file into with fs::read_to_string, Comparing Program Output
- stack and heap, Using the Result Type
metadata, Finding the Files
metadata::gid function, Formatting the Long Listing
metadata::is_dir function, Formatting the Long Listing
metadata::len function, Formatting the Long Listing, Solution
metadata::mode, Formatting the Long Listing, Displaying Octal Permissions
metadata::modified, Formatting the Long Listing
metadata::nlink, Formatting the Long Listing, Solution
metadata::uid function, Formatting the Long Listing
mkdir command, Organizing a Rust Project Directory
mk_triple helper function, Solution
mod keyword, Solution
mod owner, Solution
modified value, Solution
modules imported to finish lsr, Solution
month method, Defining and Validating the Arguments
months
- case-insensitive names for, Defining and Validating the Arguments
- current month used with calr program with no arguments, Defining and Validating the Arguments
- format_month function, Solution
- month set to none with -y|--year flag, Defining and Validating the Arguments
- parse_month function, Defining and Validating the Arguments
- provided as distinguishing substring, Defining and Validating the Arguments
- using month names to figure out the given month, Defining and Validating the Arguments
- valid integer values for, Defining and Validating the Arguments
- valid month names for parse_month, Defining and Validating the Arguments
more and less pagers, Going Further
mut (mutable) keyword, Writing and Running Integration Tests
- adding to line_num variable, Printing Line Numbers
- creating mutable print closure, Solution
- making ending variable mutable, Creating the Program Output
mv (move) command, Organizing a Rust Project Directory

-n, --lines option (tailr), Defining the Arguments
- rejecting noninteger values, Defining the Arguments
naive dates, Defining and Validating the Arguments
NaiveDate struct, Writing the Program
- constructing for start of given month, Solution
- representing last day of month, Writing the Program
NaiveDate::from_ymd, Solution
naming conventions in Rust, Defining the Arguments
newlines, Counting the Elements of a File or STDIN
- omitting using print! macro, Creating the Program Output
- on Windows and Unix, Processing the Input Files
None value (Option), Creating the Program Output

Index

Symbols

A

B

C

D

E

F

G

H

I

J

L

M

N

O

P

Q

R

S

T

U

V

W

Y

Z