September 15, 2022

Rust tuple pattern matching

One of the things I love about Rust is the ubiquity of pattern matching. This can be seen when writing expressions to handle conditional, nested logic. Handling such scenarios is a common problem.

The standard approach in most languages is writing each condition within an if block. In the center of the nested statements (often referred to as a pyramid) lies the happy path.

if let Ok(response1) = func1() {
  if let Ok(response2) = func2() {
    if let Ok(response3) = func3() {
      handleResponse(response1, response2, response3)
    } else if let Err(e) {
      handleError(e)
    }
  } else if let Err(e) {
    handleError(e)
  }
} else if let Err(e) {
  handleError(e)
}

This is messy, to say the least. I’ve seen variations like it all my life. It is difficult to read, not particularly expressive, and not well encapsulated.

So I tried to simplify it using tuples. And I learned a cool trick.

match (func1(), func2(), func3()) {
    (Ok(r1), Ok(r2), Ok(r3)) => handleResponse(r1, r2, r3),
    (Err(e), _, _) | 
    (_, Err(e), _) |
    (_, _, Err(e) => handleError(e)
}

Notice the error block. Not only does Rust allow us to add | statements to matching, it allows us to map different variants to e as long as they are of the same type.

And if we don’t care about the specificity of the error, we can simplify further:

match (func1(), func2(), func3()) {
  (Ok(r1), Ok(r2), Ok(r3)) => handleResponse(r1, r2, r3),
  _ => handleError()
}

This is a cool trick to say the least. For me, it was kind of paradigmatic. It allows my code to follow the raw business logic more closely, and escape pyramids of doom.

Edit 10/22/22 — the Rustaceans over at /r/rust provided some cool variations to this pattern. Here are a few:

Using the ? syntax with an inline closure

match (|| Ok(func1()?, func2()?, func3()?))() {
    Ok((r1, r2, r3)) => handleResponse(r1, r2, r3),     
    Err(e) => handleError(e),
}

An advantage of this style is that if the first function returns an error variant, the second and third won’t be executed.

and_then

let result = func1()
    .and_then(|r1| func2().map(|r2| (r1, r2)))
    .and_then(|(r1, r2)| func3().map(|r3| (r1, r2, r3)));
match result { 
    Ok(r) => handle_response(r), 
    Err(e) => handle_error(e), 
}

Again, this has the advantage of executing sequentially and ending execution if any of the variants return an error.

It is worth noting with both of these alternatives that you do lose a little in way of expression. If either needed to handle a new error branch, it would require a total rewrite. As with everything, there are tradeoffs. Happy hunting!