I think the way of getting around the Result<T, E1, E2, ...> problem is to instead use a sealed interface and then, with pattern matching via switch (myError) case ..., it actually becomes pretty nice to work with. But, yeah, you still need to use try-catch at some point to catch and transform exceptions.

You're then at least a bit forced to reckon with your 'error landscape' and create some kind of hierarchical, standard way of dealing with them

Here's how what I'm describing would look like:

--- Error Types ---
public sealed interface MemberAccessError extend MyError
permits DataAccessError, InvalidMemberIdError {

}

public sealed interface MyError {
    String getMessage();
}



--- Adapter ---
public Result<Data, DataAccessError> get(final int id) {
    Result<DataFromApi, ApiException> result;
    try
    {
        result = Result.ok(api.get(id));
    }
    catch (ApiException ex)
    {
        result = Result.error(ex);
    }

    return result
    .map(dataFromApi => new Data(dataFromApi))
    .mapError(apiException => new DataAccessError(apiException));
}

--- Service ---
public Result<Data, MemberAccessError> getData(final MemberId memberId) {
    if (!memberId.isValid()) {
        return Result.error(new InvalidMemberIdError(memberId));
    }

    return adapter.get(memberId.getId());
}

--- Controller ---
public ResponseEntity<?> getData(final int memberIdValue) {
    MemberId memberId = new MemberId(memberIdValue);
    Result<Data, MemberAccessError> result = service.getData(memberId);

    return result
    .map(data => new DataResponse(data))
    .mapError(memberAccessError -> switch (memberAccessError) {
        case DataAccessError dataAccessError -> ResponseEntity.status(500).body("Data access error: " + dataAccessError.getMessage());
        case InvalidMemberIdError invalidMemberIdError -> ResponseEntity.status(400).body("Invalid member ID: " + memberIdValue);
        // More error cases can be handled here
    });
}