Hi,

First of all - great initiative.

I'm a complete Rust noob and this is exactly what I was looking for - an easily digestible, short articles on Rust stdlib.

Now, when I try to execute the first example:

use std::{fs, io};

const PHOTO_HOME: &str = "/home/user/motw/week-1/";

fn main() {
    let entries = fs::read_dir(PHOTO_HOME)?
        .map(|entry_res| entry_res.map(|entry| entry.path()))
        .collect::<Result<Vec<_>, io::Error>>()?;

    println!("{:?}", entries);
}

I get the following error:

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src/main.rs:6:43
   |
5  | / fn main() {
6  | |     let entries = fs::read_dir(PHOTO_HOME)?
   | |                                           ^ cannot use the `?` operator in a function that returns `()`
7  | |         .map(|entry_res| entry_res.map(|entry| entry.path()))
8  | |         .collect::<Result<Vec<_>, io::Error>>()?;
9  | |
10 | |     println!("{:?}", entries);
11 | | }
   | |_- this function should return `Result` or `Option` to accept `?`
   |
   = help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`
   = note: required by `from_residual`

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src/main.rs:8:48
   |
5  | / fn main() {
6  | |     let entries = fs::read_dir(PHOTO_HOME)?
7  | |         .map(|entry_res| entry_res.map(|entry| entry.path()))
8  | |         .collect::<Result<Vec<_>, io::Error>>()?;
   | |                                                ^ cannot use the `?` operator in a function that returns `()`
9  | |
10 | |     println!("{:?}", entries);
11 | | }
   | |_- this function should return `Result` or `Option` to accept `?`
   |
   = help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`
   = note: required by `from_residual`

Version of Rust in use is:

stable-x86_64-unknown-linux-gnu (default)
rustc 1.54.0 (a178d0322 2021-07-26)

Could you provide hints on what could be wrong in my example?

Thanks in advance!

In group_files_by_date the clone is not needed. or_insert_withis more efficient in the case where a value already exists, because the closure or function provided to it are only executed if needed, while or_insert always creates the value.

BTW keep up the good work. I really enjoyed those posts! :)

fn visit_dirs(dir: &Path) -> io::Result<Vec<PathBuf>> {
    let mut stack = vec![fs::read_dir(dir)?];
    let mut files = vec![];
    while let Some(dir) = stack.last_mut() {
        match dir.next().transpose()? { // r: dir.find_map(|r| r.ok())
            None => {
                stack.pop();
            }
            Some(dir) if dir.file_type().map_or(false, |t| t.is_dir()) => {
                stack.push(fs::read_dir(dir.path())?); // stack.extend(fs::read_dir(dir.path()))
            }
            Some(file) => files.push(file.path()),
        }
    }
    Ok(files)
}

Recursion in Rust isn't specially optimised, so iterative solutions are often faster (in this case 3x). I think it would be good to make a note of this.

Also, it's often better to just ignore errors returned from the ReadDir since they can have different permission flags etc. In these cases discarding the rest of the results can be overly pessimistic.

As mentioned in #7 I wanted to have a clean build and release process. It's working for the draft branch, now it's time to bring it to the main branch before content changes/suggestions come in.

Enable continuous testing by some means. Whether through doctests or unit tests it would behoove us to have automatic testing and use it as a barrier to any merges.

#9 addresses a bug in one of the code samples. That made me thinking.

What if we the examples can be tested automatically, similar to Rust's doc tests? Than issue like the one reported in #9 can be prevented.

And what do you think about making the code sample executable in the web browser? The rust book offers that for many of it's examples.

Rudgal gets serious about organizing. Will have to include some sort of generating function so the moving/organizing can be demonstrated.

• DirBuilder
• Permissions
• Copying/removing files.