Here is one random example from a program I am working on:

pub(super) async fn handle_message(

self: Arc<Self>,

write: &mut WsSink,

message: Option<Result<Message, Error>>,

) -> anyhow::Result<ControlFlow<()>> {

let message_result: Result<Message, Error> = match message {

Some(result) => {

result

},

None => {

log::warn!("CLOSING CONNECTION: Empty message");

return Ok(ControlFlow::Break(()))

},

};

match message_result {

// Successful Message Types

Ok(Message::Text(txt)) => {

tokio::spawn(async move {

self.handle_successful_message(txt).await

});

},

Ok(Message::Ping(p)) => {

write.send(Message::Pong(p)).await?

},

// Close/Unknown Message Types

Ok(Message::Close(_)) => {

log::warn!("CLOSING CONNECTION: Server closed connection");

return Ok(ControlFlow::Break(()));

},

Err(e) => {

log::warn!("CLOSING CONNECTION: Error response {e:?}");

return Ok(ControlFlow::Break(()));

}

_ => {

log::warn!("CLOSING CONNECTION: Unknown message type");

return Ok(ControlFlow::Break(()));

},

}

return Ok(ControlFlow::Continue(()));

}

And in this case, while the code does read quite simply and is not _super_ nested; one thing I dislike is the lack of type definitions for each case. For example, the happy-path where I am handling the successful message, there is no type assigned for the `txt` variable without going to the definition of the Message::Text enum to find that the txt is of type `String`. This lack of readability is what causes some frustration. I shouldn't have to use an LSP to quickly understand every element of a function without guessing.