Auto wrap of () in Ok() for functions returning Result<(), Error_Type>

[b-will-c]

@mbrubeck

This is closely related to try blocks, which have the auto-wrapping behavior you desire.

There have been a few different proposals for try fn or fn = try syntax that performs this wrapping at the function level, analogous to async fn .

Although the idea has its place, it's a bit too cumbersome - the "try" syntax doesn't belong in Rust, although that might just be might own opinionated mind speaking. It does have its use, namely:

let result: Result<i32, ParseIntError> = try {
    "1".parse::<i32>()?
        + "2".parse::<i32>()?
        + "3".parse::<i32>()?
};

however, it's a bit different from a silent wrap in an Ok at the end. This is explicit, a wrap isn't - which is where its beauty lies and why we're able to omit the Units at the end of the functions' body.

@mbrubeck

The fehler crate implements a similar syntax as a macro.

That's actually very neat - I might just use it the next time. A silent wrap would still be better.

@mbrubeck

Another somewhat relevant discussion recently: [Pre-RFC] Result::void() and Option::void()

Yup, exactly my point. I especially relate to this:

@fosskers

So from day-1 of my Rust journey, Ok(()) struck me as code smell.

I understand the logic behind the Unit, but the parenthesis were never meant to wrap an empty space. If we know there's nothing to return, and we know we need to return a Result, let's just do it.

Another reason why I'd love to have a silent Ok wrapper is that it doesn't change anything - no new language constructs, no complexities - just a compiler to check to see if there's a () at the end of a function that should be returning a Result<(), _> - and silently handling it. No complications.

@matklad

It's interesting that it actually does do that, it's just the unit spelled as ; . Ie, we can imagine a hypothetical Rust which doesn't have ; , and just infers whether you meant to return a value or a unit from the function. In today's Rust, ; is a syntactic marker which distinguishes unit blocks from value blocks.

Oh, wow - really? Didn't know that. So each and every time I end a statement I actually return a Unit from it? That's fascinating to know. But I still want my wrappers.