4 ms·
I have noticed this tendency as well. To counteract it, I write exit-early code like this: let foo_result = foo(); if let Err(e) = foo_result {
by aaron_m04 4y ago
I have noticed this tendency as well.
To counteract it, I write exit-early code like this:
let foo_result = foo();
if let Err(e) = foo_result {
return Bar::Fail(e);
}
let foo_result = foo_result.unwrap();
...
- ntoskrnl 4y agoI do this too, with a different spin on it: let foo = match foo() { Ok(foo) => foo, Err(err) => return Err(err), }; I was typing it out so often I made editor aliases `lmo` and `lmr` for Option and Result
- veber-alex 4y agolet me introduce you to the famous '?' operator. The code above can be written as: let foo = foo()?;
- ntoskrnl 4y agoLOL you're right! I just pasted the template here, but my defaults are mostly equivalent to plain old `?`. I don't use the match if `?` would work.
- mathstuf 4y agoAny reason why this wasn't preferred? let foo_result = foo() .map_err(Bar::Fail)?;
- veber-alex 4y agoBar::Fail is not wrapped in a Result type, so you can't use '?' with it (on stable at least). You can write it like this: let foo_result = match foo() { Ok(v) => v, Err(e) => return Bar::Fail(e) };
- loeg 4y agoThe result type is the return from Foo -- Bar::Fail does not need to wrap Result. Foo is Result<T, E> and map_err() would convert it to Result<T, Bar::Fail>. I think GP's `map_err()?` is the most straightforward way of writing this idea (and it's generally speaking how I would suggest writing Rust code).
- veber-alex 4y agoGP's code will return Result<_, Bar>, the original code we are trying to fix just returns Bar.
- loeg 4y agoIf you are writing code to handle Results, it’s going to be a lot less painful to just return Result.
- gardaani 4y agoEarly exit code would be easier to write if Rust supported guard let.
- klodolph 4y agoLike this? if let Ok(x) = my_func() { // ... } Or do you mean something else?
- veber-alex 4y agoits coming soon, already available on nightly. let Some(x) = foo() else { return 42 };
- inferiorhuman 4y agoI'd suggest that something like that is already achievable by having foo return an Option and combining it with unwrap_or.
- metaltyphoon 4y agoIsn’t that a good general practice todo? Exit early
- icedchai 4y agoYou'd be surprised. For every person that things exit early is good, you'll run into another that prefers a single exit. At worked at a C++ shop that preferred "single exit", and some methods with an ungodly amount of conditions just to make this possible. Ugh.
- boolemancer 4y agoIn my experience, a preference for single exit comes from C where you always need to make sure to clean up any resources, and an early exit is a great way to have to duplicate a bunch of cleanup logic or accidentally forget to clean things up. Of course, that's what goto is actually good for.