Combining Types

// Option<T> → Result<T, E>
Result<String, String> r1 = option.toResult("value was absent");
// or with a computed error:
Result<String, AppError> r2 = option.fold(Result::ok, () -> Result.err(AppError.MISSING));

// Option<T> → Try<T>
Try<String> t1 = option.toTry(() -> new NoSuchElementException("absent"));

// Try<T> → Result<T, Throwable>
Result<String, Throwable> r3 = tryValue.toResult();

// Try<T> → Result<T, E>  (map the exception to a domain error)
Result<String, AppError> r4 = tryValue.toResult(ex -> AppError.from(ex));

// Try<T> → Option<T>
Option<String> o1 = tryValue.toOption(); // Some on success, None on failure

// Result<T, E> → Option<T>  (discards the error)
Option<String> o2 = result.toOption();   // Some(value) or None

// Result<T, E> → Try<T>
Try<String> t2 = result.toTry(AppError::toException);

// Validated<E, A> → Result<A, E>
Result<UserForm, List<String>> r5 = validated.toResult();

// Validate with Validated — accumulate ALL errors, then hand off to the
// repository which speaks Result (fail-fast, single error path).

public Result<User, List<String>> register(RegistrationRequest req) {

    Validated<NonEmptyList<String>, RegistrationForm> validation =
        validateEmail(req.email())
            .combine(validatePassword(req.password()), NonEmptyList::concat, RegistrationForm::new);

    // Convert Validated → Result before hitting the database
    return switch (validation) {
        case Validated.Valid<?, RegistrationForm>(var form) ->
            userRepository.save(form);          // returns Result<User, List<String>>
        case Validated.Invalid<NonEmptyList<String>, ?>(var errors) ->
            Result.err(errors.toList());        // surface all validation errors
    };
}

// Chain Option → Try → Result in a single pipeline.
// Convert at the boundary where the next operation's type demands it.

Option<Config>   config = configStore.load();          // absent = not configured

// Option → Try: treat absence as an exceptional state for this path
Try<Connection> conn = config
    .toTry(() -> new MissingConfigException("database config not found"))
    .flatMap(cfg -> Try.of(() -> DataSource.connect(cfg.dbUrl())));

// Try → Result: surface a domain error to the caller
Result<Data, String> data = conn
    .toResult(ex -> "Connection failed: " + ex.getMessage())
    .flatMap(c -> fetchData(c));   // fetchData returns Result<Data, String>

// Run two independent validated computations and combine their results
// into a Tuple2 — errors from both are accumulated via NonEmptyList::concat.

Validated<NonEmptyList<String>, Email>    emailV    = validateEmail(req.email());
Validated<NonEmptyList<String>, Username> usernameV = validateUsername(req.username());

Validated<NonEmptyList<String>, Tuple2<Email, Username>> combined =
    emailV.combine(usernameV, NonEmptyList::concat, Tuple2::new);

// Collapse the tuple into a domain object once both values are valid
Validated<NonEmptyList<String>, UserDraft> draft =
    emailV.combine(usernameV, NonEmptyList::concat,
        (email, username) -> new UserDraft(email, username));

// Option.traverse — apply a function that may return None; short-circuits on first None
List<Long> userIds = List.of(1L, 2L, 3L);

Option<List<User>> users = Option.traverse(userIds, id -> userRepo.findById(id));
// Some([user1, user2, user3]) if all are found; None if any id is missing

// Result.traverse — apply a function that may return Err; short-circuits on first Err
List<String> orderRefs = List.of("ORD-1", "ORD-2", "ORD-3");

Result<List<Order>, String> orders =
    Result.traverse(orderRefs, ref -> orderService.load(ref));
// Ok([order1, order2, order3]) if all succeed; Err("...") on first failure

// Try.traverse — apply a checked operation to each element; stops on first exception
List<Path> paths = List.of(Paths.get("a.txt"), Paths.get("b.txt"));

Try<List<String>> contents =
    Try.traverse(paths, path -> Try.of(() -> Files.readString(path)));
// Success([...]) if all reads succeed; Failure(IOException) on first error

// Wrap a legacy checked API with Try, then convert to Result at the service boundary.
// The caller receives a typed domain error — not a raw exception.

Result<Report, AppError> report =
    Try.of(() -> legacyReportService.generate(params))   // CheckedSupplier
       .toResult(ex -> AppError.from("report-generation-failed", ex));

// The same pattern for Optional-returning legacy APIs:
Result<Config, AppError> config =
    Try.of(() -> legacyConfigLoader.load())              // may throw or return null
       .flatMap(cfg -> cfg != null
           ? Try.success(cfg)
           : Try.failure(new MissingConfigException()))
       .toResult(AppError::from);

// Bad: unnecessary chain of conversions — each conversion loses information
// and makes the pipeline harder to follow.
Result<String, AppError> result =
    Try.of(() -> fetchValue())
       .toOption()                          // discards the exception — why?
       .toTry(() -> new RuntimeException()) // re-wraps into a less informative exception
       .toResult(AppError::from);           // finally converts to Result

// Good: stay in Try and convert directly to Result at the end
Result<String, AppError> result2 =
    Try.of(() -> fetchValue())
       .toResult(AppError::from);

// Bad: converting to Option mid-pipeline just to call getOrElseGet
String value = Try.of(() -> fetchValue())
    .toOption()                             // exception silently discarded
    .getOrElseGet(() -> "default");

// Good: use Try's own recovery methods — the exception is still accessible
String value2 = Try.of(() -> fetchValue())
    .getOrElse("default");
// or, if you need the exception:
String value3 = Try.of(() -> fetchValue())
    .recover(ex -> "default (error: " + ex.getMessage() + ")");