Witness Type: EitherTKind<F, L, R> extends Kind<EitherTKind.Witness<F, L>, R>. The types F and L are fixed for a given context; R is the variable value type.

KindHelper: EitherTKindHelper provides EITHER_T.widen and EITHER_T.narrow for safe conversion between the concrete EitherT<F, L, R> and its Kind representation.

// Widen: concrete → Kind
Kind<EitherTKind.Witness<F, L>, R> kind = EITHER_T.widen(eitherT);

// Narrow: Kind → concrete
EitherT<F, L, R> concrete = EITHER_T.narrow(kind);

EitherT provides several factory methods for different starting points:

Monad<OptionalKind.Witness> optMonad = OptionalMonad.INSTANCE;

// 1. From a pure Right value: F<Right(value)>
EitherT<OptionalKind.Witness, String, String> etRight =
    EitherT.right(optMonad, "OK");

// 2. From a pure Left value: F<Left(error)>
EitherT<OptionalKind.Witness, String, Integer> etLeft =
    EitherT.left(optMonad, "FAILED");

// 3. From an existing Either: F<Either(input)>
Either<String, String> plainEither = Either.left("FAILED");
EitherT<OptionalKind.Witness, String, String> etFromEither =
    EitherT.fromEither(optMonad, plainEither);

// 4. Lifting an outer monad value F<R> → F<Right(R)>
Kind<OptionalKind.Witness, Integer> outerOptional =
    OPTIONAL.widen(Optional.of(123));
EitherT<OptionalKind.Witness, String, Integer> etLiftF =
    EitherT.liftF(optMonad, outerOptional);

// 5. Wrapping an existing nested Kind F<Either<L, R>>
Kind<OptionalKind.Witness, Either<String, String>> nestedKind =
    OPTIONAL.widen(Optional.of(Either.right("OK")));
EitherT<OptionalKind.Witness, String, String> etFromKind =
    EitherT.fromKind(nestedKind);

// Accessing the wrapped value:
Kind<OptionalKind.Witness, Either<String, String>> wrappedValue = etRight.value();
Optional<Either<String, String>> unwrappedOptional = OPTIONAL.narrow(wrappedValue);
// → Optional.of(Either.right("OK"))

• EitherTExample.java

The problem: You need to validate input, process it asynchronously, and handle domain-specific errors at each step, all without nested thenCompose/fold chains.

The solution:

public class EitherTExample {

  record DomainError(String message) {}
  record ValidatedData(String data) {}
  record ProcessedData(String data) {}

  MonadError<CompletableFutureKind.Witness, Throwable> futureMonad =
      CompletableFutureMonad.INSTANCE;
  MonadError<EitherTKind.Witness<CompletableFutureKind.Witness, DomainError>,
      DomainError> eitherTMonad = new EitherTMonad<>(futureMonad);

  // Sync validation returning Either
  Kind<EitherKind.Witness<DomainError>, ValidatedData> validateSync(String input) {
    if (input.isEmpty()) {
      return EITHER.widen(Either.left(new DomainError("Input empty")));
    }
    return EITHER.widen(Either.right(new ValidatedData("Validated:" + input)));
  }

  // Async processing returning Future<Either>
  Kind<CompletableFutureKind.Witness, Either<DomainError, ProcessedData>>
      processAsync(ValidatedData vd) {
    CompletableFuture<Either<DomainError, ProcessedData>> future =
        CompletableFuture.supplyAsync(() -> {
          if (vd.data().contains("fail")) {
            return Either.left(new DomainError("Processing failed"));
          }
          return Either.right(new ProcessedData("Processed:" + vd.data()));
        });
    return FUTURE.widen(future);
  }

  Kind<CompletableFutureKind.Witness, Either<DomainError, ProcessedData>>
      runWorkflow(String input) {
    // Lift initial value into EitherT
    var initialET = eitherTMonad.of(input);

    // Step 1: Validate (sync Either → EitherT)
    var validatedET = eitherTMonad.flatMap(
        in -> EitherT.fromEither(futureMonad, EITHER.narrow(validateSync(in))),
        initialET);

    // Step 2: Process (async Future<Either> → EitherT)
    var processedET = eitherTMonad.flatMap(
        vd -> EitherT.fromKind(processAsync(vd)),
        validatedET);

    // Unwrap to get Future<Either>
    return EITHER_T.narrow(processedET).value();
  }
}

Why this works: Each step produces an EitherT value. The flatMap handles both the CompletableFuture sequencing and the Either error propagation. If validation returns Left, processing is skipped entirely. No manual error checking at any point.

• OrderWorkflowRunner.java

The problem: A shipping step might fail with a temporary error, and you want to recover by using a default shipping option rather than failing the entire workflow.

The solution:

// Attempt shipment
Kind<EitherTKind.Witness<CompletableFutureKind.Witness, DomainError>,
    ShipmentInfo> shipmentAttemptET =
    EitherT.fromKind(steps.createShipmentAsync(orderId, address));

// Recover from specific errors
Kind<EitherTKind.Witness<CompletableFutureKind.Witness, DomainError>,
    ShipmentInfo> recoveredShipmentET =
    eitherTMonad.handleErrorWith(
        shipmentAttemptET,
        error -> {
            if (error instanceof DomainError.ShippingError se
                    && "Temporary Glitch".equals(se.reason())) {
                // Recoverable: use default shipping
                return eitherTMonad.of(new ShipmentInfo("DEFAULT_SHIPPING_USED"));
            } else {
                // Non-recoverable: re-raise
                return eitherTMonad.raiseError(error);
            }
        });

The handleErrorWith only fires when the inner Either is Left. The outer CompletableFuture context is preserved throughout.

Without HKT simulation, you would need a separate transformer for each outer monad: EitherTOptional, EitherTFuture, EitherTIO, and so on. Higher-Kinded-J's Kind<F, A> interface means there is one EitherT and one EitherTMonad that works generically for any outer monad F for which a Monad<F> instance exists. You provide the outer monad at construction time; the transformer does the rest.