What is the equivalent of 'pass' from Python?

Question

I want to check if the result from a request is having any issue. I categorize it into two: i) server error, ii) something else that is not a success. The third category is, result actually being a success. However, in the third category, I don't want to do anything.

So, my desirable code is:

if res.status().is_server_error() {
        panic!("server error!");
    } else if !(res.status.is_success()){
        panic!("Something else happened. Status: {:?}", res.status());
    } else{
        pass;
    }

I am aware of other ways to achieve this result: using match, ifs instead of if else if. But I wanted to learn what is the corresponding keyword of pass, like we have in Python. My aim is: if result is successful, just move along, if not, there are two ways to handle that panic.

Answer 1

Behold!

if predicate {
    do_things();
} else {
    // pass
}

Or even better

if predicate {
    do_things();
} // pass

Or as I’ve recently taken to calling it the implicit + pass system

if predicate {
    do_things();
}

In all seriousness there is no pass and no need for a pass in rust. As for why it exists in python, check out this answer

Answer 2

Python needs pass because it uses indentation-based blocks, so it requires some syntax to "do nothing". For example, this would be a syntax error in a Python program:

# syntax error - function definition cannot be empty
def ignore(_doc):
    # do nothing

count = process_docs(docs, ignore)  # just count the docs

The ignore function has to contain a block, which in turn must contain at least one statement. We could insert a dummy statement like None, but Python provides pass which compiles to nothing and signals the intention (to do nothing) to the human reader.

This is not needed in Rust because Rust uses braces for blocks, so one can always create an empty block simply using {}:

// no error - empty blocks are fine
fn ignore(_doc: &Document) {
    // do nothing
}

let count = process_docs(docs, ignore);  // just count the docs

Of course, in both idiomatic Python and Rust, one would use a closure for something as simple as the above ignore function, but there are still situations where pass and empty blocks are genuinely useful.