Rust will also let you: "FOO".contains(char::is_uppercase)

That's showing off three clever tricks Rust has that C++ does not, but one day it will just be compile time evaluated as true and that's one place C++ is richer today. Many other things in Rust can be but Rust's traits aren't today allowed to be compile time evaluated, so the fact that we could determine at compile time whether there's an uppercase letter in FOO isn't enough yet. One day.

    struct Logger;
    
    impl Logger {
        fn log(&self, _: &str) {}
    }
    
    fn do_something(data: &str, logger: Option<Logger>) {
        for l in logger {
            l.log(data)
        }
    }
    
    fn main() {
        let logger = Some(Logger);
        let data = "foo";
        
        do_something(data, logger);
    }

    warning: for loop over an `Option`. This is more readably written as an `if let` statement
     --> src/main.rs:8:14
      |
    8 |     for l in logger {
      |              ^^^^^^
      |
      = note: `#[warn(for_loops_over_fallibles)]` on by default
    help: to check pattern in a loop use `while let`
      |
    8 -     for l in logger {
    8 +     while let Some(l) = logger {
      |
    help: consider using `if let` to clear intent
      |
    8 -     for l in logger {
    8 +     if let Some(l) = logger {
      |

I think this is most useful in generic contexts, I agree that I would not write this exact code this way because it does feel weird, if you know you have an Option, if let is the way to go. But if you're writing code over generic iterators, it can be nice that it exists.