Remember, you may have solved this differently from me, but a passing test suite is all that matters. I will walk you through how I arrived at a solution, starting with how I filter for entry types:

pub fn run(config: Config) -> MyResult<()> {
    for path in config.paths {
        for entry in WalkDir::new(path) {
            match entry {
                Err(e) => eprintln!("{}", e),
                Ok(entry) => {
                    if config.entry_types.is_empty() 
                        || config.entry_types.iter().any(|entry_type| {
                            match entry_type { 
                                Link => entry.file_type().is_symlink(),
                                Dir => entry.file_type().is_dir(),
                                File => entry.file_type().is_file(),
                            }
                        })
                    {
                        println!("{}", entry.path().display()); 
                    }
                }
            }
        }
    }
    Ok(())
}

Check if no entry types are indicated.

If there are entry types, use Iterator::any to see if any of the desired types match the entry’s type.

Print only those entries matching the selection criteria.

Recall that I used Iterator::all in Chapter 5 to return true if all of the elements in a vector passed some predicate. In the preceding code, I’m using Iterator::any to return true if at least one of the elements proves true for the predicate, which in this case is whether the entry’s type matches one of the desired types. When I check the output, it seems to be finding, for instance, all the directories:

$ cargo run -- tests/inputs/ -t d
tests/inputs/
tests/inputs/a
tests/inputs/a/b
tests/inputs/a/b/c
tests/inputs/f
tests/inputs/d
tests/inputs/d/e

pub fn run(config: Config) -> MyResult<()> {
    for path in config.paths {
        for entry in WalkDir::new(path) {
            match entry {
                Err(e) => eprintln!("{}", e),
                Ok(entry) => {
                    if (config.entry_types.is_empty() 
                        || config.entry_types.iter().any(|entry_type| {
                            match entry_type {
                                Link => entry.file_type().is_symlink(),
                                Dir => entry.file_type().is_dir(),
                                File => entry.file_type().is_file(),
                            }
                        }))
                        && (config.names.is_empty() 
                            || config.names.iter().any(|re| { 
                                re.is_match(
                                    &entry.file_name().to_string_lossy(),
                                )
                            }))
                    {
                        println!("{}", entry.path().display());
                    }
                }
            }
        }
    }
    Ok(())
}

Check the entry type as before.

Combine the entry type check using && with a similar check on the given names.

Use Iterator::any again to check if any of the provided regexes match the current filename.

$ cargo run -- tests/inputs/ -t f -n mp3
tests/inputs/a/b/c/c.mp3
tests/inputs/d/e/e.mp3

I want to refactor this code, which means I want to restructure it without changing the way it works. Refactoring is only possible once I have a working solution, and tests help ensure that any changes I make still work as expected. Specifically, I want to find a less convoluted way to select the entries to display. These are filter operations, so I’d like to use Iterator::filter, and I’ll show you why. Following is my final run that still passes all the tests. Be sure you add use walkdir::DirEntry to your code for this:

pub fn run(config: Config) -> MyResult<()> {
    let type_filter = |entry: &DirEntry| { 
        config.entry_types.is_empty()
            || config
                .entry_types
                .iter()
                .any(|entry_type| match entry_type {
                    Link => entry.path_is_symlink(),
                    Dir => entry.file_type().is_dir(),
                    File => entry.file_type().is_file(),
                })
    };

    let name_filter = |entry: &DirEntry| { 
        config.names.is_empty()
            || config
                .names
                .iter()
                .any(|re| re.is_match(&entry.file_name().to_string_lossy()))
    };

    for path in &config.paths {
        let entries = WalkDir::new(path)
            .into_iter()
            .filter_map(|e| match e { 
                Err(e) => {
                    eprintln!("{}", e);
                    None
                }
                Ok(entry) => Some(entry),
            })
            .filter(type_filter) 
            .filter(name_filter) 
            .map(|entry| entry.path().display().to_string()) 
            .collect::<Vec<_>>(); 

        println!("{}", entries.join("\n")); 
    }

    Ok(())
}

Create a closure to filter entries on any of the regular expressions.

Create a similar closure to filter entries by any of the types.

Turn WalkDir into an iterator and use Iterator::filter_map to remove and print bad results to STDERR while allowing Ok results to pass through.

Filter out unwanted types.

Filter out unwanted names.

Turn each DirEntry into a string to display.

Use Iterator::collect to create a vector.

Join the found entries on newlines and print.

In the preceding code, I create two closures to use with filter operations. I chose to use closures because I wanted to capture values from the config. The first closure checks if any of the config.entry_types match the DirEntry::file_type:

let type_filter = |entry: &DirEntry| {
    config.entry_types.is_empty() 
        || config
            .entry_types
            .iter()
            .any(|entry_type| match entry_type { 
                Link => entry.file_type().is_symlink(), 
                Dir => entry.file_type().is_dir(), 
                File => entry.file_type().is_file(), 
            })
};

Return true immediately if no entry types have been indicated.

Otherwise, iterate over the config.entry_types to compare to the given entry type.

When the entry type is Link, use the DirEntry::file_type function to call FileType::is_symlink.

When the entry type is Dir, similarly use FileType::is_dir.

When the entry type is File, similarly use FileType::is_file.

let type_filter = |entry: &DirEntry| {
    config.entry_types.is_empty()
        || config
            .entry_types
            .iter()
            .any(|entry_type| match entry_type {
                Link => entry.file_type().is_symlink(),
                Dir => entry.file_type().is_dir(),
                //File => entry.file_type().is_file(), // Will not compile
            })
};

The compiler stops and politely explains that you have not handled the case of the EntryType::File variant. You will not get this kind of safety if you use strings to model this. The enum type makes your code far safer and easier to verify and modify:

error[E0004]: non-exhaustive patterns: `&File` not covered
  --> src/lib.rs:99:41
   |
10 | / enum EntryType {
11 | |     Dir,
12 | |     File,
   | |     ---- not covered
13 | |     Link,
14 | | }
   | |_- `EntryType` defined here
...
99 |                   .any(|entry_type| match entry_type {
   |                                           ^^^^^^^^^^ pattern `&File`
   |                                                      not covered
   |
   = help: ensure that all possible cases are being handled, possibly by
     adding wildcards or more match arms
   = note: the matched value is of type `&EntryType`

The second closure is used to remove filenames that don’t match one of the given regular expressions:

let name_filter = |entry: &DirEntry| {
    config.names.is_empty() 
        || config
            .names
            .iter()
            .any(|re| re.is_match(&entry.file_name().to_string_lossy())) 
};

Return true immediately if no name regexes are present.

Use Iterator::any to check if the DirEntry::file_name matches any one of the regexes.

The last thing I’ll highlight is the multiple operations I can chain together with iterators in the following code. As with reading lines from a file or entries in a directory, each value in the iterator is a Result that might yield a DirEntry value. I use Itera⁠tor​::filter_map to map each Result into a closure that prints errors to STDERR and removes by them by returning None; otherwise, the Ok values are allowed to pass by turning them into Some values. The valid DirEntry values are then passed to the filters for types and names before being shunted to the map operation to transform them into String values:

let entries = WalkDir::new(path)
    .into_iter()
    .filter_map(|e| match e {
        Err(e) => {
            eprintln!("{}", e);
            None
        }
        Ok(entry) => Some(entry),
    })
    .filter(type_filter)
    .filter(name_filter)
    .map(|entry| entry.path().display().to_string())
    .collect::<Vec<_>>();