Fluency in Result

[paullatzelsperger]

While using the (great) Result class, I was wondering whether we could/should add some syntactic sugar to it that allows us to use it in a more fluent way.
I do not yet have a comprehensive list, but the following scenarios came to mind:

// 1. fluent if:
var someResult = getSomeResult();
someResult.ifSuccess(r -> doSomething(r.getContent()));
someResult.ifFailure(r -> doSomethingElse(r.getContent()));

// 2. map to type implicit
public Result<Void> someMethod(){
    Result<String> result = getStringResult();
    return result.mapTo();
}

// 3. or-else semantics similar to Optional
var someResult = getSomeResult();
someResult.whenSuccessFul(r -> doSomething()).orElse(r -> doSomethingElse);

someResult.whenSuccessFul(r -> doSomething()).orElseThrow(() -> new FooBarException());

// 4. chaining multiple results:
var firstResult = getFirstResult();
//in case firstResult failed, the chain immediately returns
return firstResult.whenSuccess(r -> getSecondResult()) //only executes if firstResult.succeeded()
                  .whenSuccess(r2 -> getThirdResult()) //only executes if r2.succeeded(), returns result of getThirdResult()

// 5. mapping to Optional, to integrate with Streams
Result<String> result = getSomeResult();
Optional<String> opt = result.asOptional(); // empty if failed

For me, this really surfaced when dealing with Results of different types, converting one into the other, executing code conditionally, using and mapping Streams, etc.

I have not thought about the implementation aspects in great detail yet, rather from a "as a user I want" perspective, but I would be happy to dig into this some more.

Keen to hear peoples' opinions!

[ndr-brt]

Actually love these ideas:

1. I remember working on a branch (that was discarded at the end) where I introduced the onSuccess and onFailure that did the same thing as the ifSuccess and ifFailure, they can be useful in a lot of cases.
2. mapTo seems also good.
3. Seems not to different from point 1, but I dig that sintax more
4. Is this similar to a flatMap (or compose) approach, right? passing a function that returns a Result itself and flattening the result. If so, I like it
5. This could also be useful.

[paullatzelsperger]

cool, sounds great! In addition to this, explicit mapping like

Result<String> result = getResult();
var voidResult = result.mapTo(Void.class);

could also come in handy at times.

ad 4: yes, actually quite similar to Optional.flatMap. Since this is not a high priority feature request, I'd suggest creating an issue for it for M6 and collecting the aforementioned use cases, and potentially additional ones, therein?

[ndr-brt]

Yes, maybe we can see if are there cases where they will become handy in the current codebase, so their introduction will be more than justified :)

[paullatzelsperger]

i can think of a few, especially in downstream projects (RegistrationService, IdentityHub)

[paullatzelsperger]

created #1823