Announcing Rust 1.89.0 (blog.rust-lang.org)
from nemeski@mander.xyz to rust@programming.dev on 07 Aug 13:24
https://mander.xyz/post/35482700

#rust

threaded - newest

Ephera@lemmy.ml on 07 Aug 16:14 collapse

Result::flatten() is probably my favorite addition, but those lifetime linter changes might be really good, too.

BB_C@programming.dev on 07 Aug 17:48 next collapse

Result::flatten() is probably my favorite addition

It’s rare to a have a negative reaction to a library addition. But I don’t like this one at all actually.

For me, error contexts are as important as the errors themselves. And ergonomically helping with muddying these contexts is not a good thing!

NGram@piefed.ca on 07 Aug 17:58 collapse

What scenarios do you envision a Result<Result<T, E>, E> having a different meaning than a Result<T, E>? To me, the messy Result type just seems like a case of something that should've been handled already (or properly propagated up).

BB_C@programming.dev on 07 Aug 20:02 collapse

(stating the obvious)

You can already :

res_res??;
// or
res_res?.map_err(..)?;
// or
res_res.map_err(...)??;
// or
res_res.map_err(...)?.map_err(...)?;

With res_res.flatten()?, you don’t know where you got the error anymore, unless the error type itself is “flatten-aware”, which is a bigger adjustment than the simple ergonomic library addition, and can become itself a problematic pattern with its own disadvantages.

Ephera@lemmy.ml on 07 Aug 20:12 next collapse

Yeah, I can see your point. It’s certainly not something you should overuse, just because it’s convenient.

I feel like the redeeming points are that it will only be available, if it’s the same error type. And if you use a catch-all error type, like anyhow::Error, which makes it likely for nested results to use the same error type, then it’s likely that you can use ?? already.
So, personally, I feel like it isn’t something that juniors will readily/wrongfully incorporate into their error handling routine and rather it is a tool that’s available for when you know what you’re doing.

anton@lemmy.blahaj.zone on 07 Aug 20:13 next collapse

You can already :

res_res??;

I think it’s more for cases where you don’t want to return, like

let new_res = old_res.map(func).flatten();
sukhmel@programming.dev on 07 Aug 21:59 collapse

This, it’s not a thing that happens often, but there were a couple of times when flatten would’ve been handy

This was also usually a result of a chain of and_then that could do with some flattening. This could’ve been rewritten as a separate function to make use of ?, but it seems to be a bigger trouble than use

TehPers@beehaw.org on 07 Aug 20:17 next collapse

A lot of code doesn’t really care where the error came from. This can be useful when using anyhow in application code, for example.

For library code, I don’t see myself really using it, so it’ll live next to all the other functions I don’t use there I guess.

sukhmel@programming.dev on 09 Aug 09:38 collapse

Wait, so you say res_res?? gives more information than res_res.flatten()?, do you?

I mean, this is a very trivial case and not best suited for flatten at all, but the information is lost in exactly the same way

BB_C@programming.dev on 09 Aug 17:16 collapse

Yes. Note that I’m replying to this:

messy Result type just seems like a case of something that should’ve been handled already (or properly propagated up).

My point was that without flattening, “provide context and propagate” vs. “directly propagate” is always explicit and precise, and is obviously already supported and easy to do.

Use with functional chaining, as pointed out by others, wasn’t lost on me either. I’ve been using Option::flatten() for years already, because such considerations don’t exist in that case.

sugar_in_your_tea@sh.itjust.works on 08 Aug 14:13 collapse

I’m more excited about File::lock and friends. I don’t currently have a use-case, but surely it’ll help w/ something like a SQLite implementation in Rust.

XTL@sopuli.xyz on 08 Aug 16:16 collapse