Introduce Result.failure(Exception ex) method to propagate exception as failure result to caller

[pratapipatelbcone]

Current State

A method throws some exception which is represented as a failure result via

Result<Data> someMethod() {

  try {
    var data = service.getData();
    return Result.success(data);
  } catch (Exception ex) {
    return Result.failure(ex.getMessage()); // Here we lost exception information and stack trace. 
  }
}

Proposed Way

Result<Data> someMethod() {

  try {
    var data = service.getData();
    return Result.success(data);
  } catch (Exception ex) {
    return Result.failure(ex); // or Result.failure("service failed to fetch data", ex);
  }
}

Motivation

• Many a time, a stack trace is not printed, but exception message is propagated further.
• As soon as exception information is lost, caller can't log the stack trace to help debug the issue.
• Stack trace help debug issues, when we have a large code base and lots of flow.

Proposed Methods

class Result {
  public static Result failure(Exception ex) {
    return failure(ex.getMessage(), ex);
  }
  
  public static Result failure(String msg, Exception ex) {
    return new Result(null, new Failure(msg, ex));
  }
}

• Failure class should hold the exception.
• All other sub classes of Result should also define similar methods.
• Throwable can be used in place of Exception

[ndr-brt]

the idea is valuable, I'd like to hear more about what will be the future getFailureDetail, that is currently the central point of convergence in the very moment the failure is evaluated.

Plus I'd like to hear why:

Throwable can be used in place of Exception

that doesn't sound like a good idea to do so but maybe I'm missing the point.

[pratapipatelbcone]

I think getFailureDetail should not be modified to keep backward compatibility.

Failure class should introduce a new field called cause to hold the exception. And a new method getCause().

public class Failure {
    private final List<String> messages;
    private final Exception ex;

    public Failure(List<String> messages) {
        this(messages, null):
    }

    public Failure(List<String> messages, Exception cause) {
        this.messages = messages;
        this.cause = cause;
    }

    public List<String> getMessages() {
        return messages;
    }

    public Exception getCause() {
        return cause;
    }

    public String getFailureDetail() {
        return String.join(", ", messages);
    }
}

Further this can be consumed as below

Result<Data> someMethod() {
    ...
}

someMethod().onFailure(f -> monitor.severe(f.getFailureDetail(), f.getCause())) # It will print stack trace

[pratapipatelbcone]

Throwable can be used in place of Exception
that doesn't sound like a good idea to do so but maybe I'm missing the point.

Throwable is just a root class for exceptions in Java, so Throwable becomes more generic.
Probably for the same reason, Monitor also accepts Throwable in params, so logging via monitor will align with that.

public interface Monitor {

    default void severe(Supplier<String> supplier, Throwable... errors) {
    }
}

[ndr-brt]

Would you mind create an issue for this? Given that it's involving core classes it will require a decision record prior to implementation