For handling exceptions specifically, see Try Monad, which is an Either specialised with Throwable as the error type. For fail-fast validation with error accumulation in applicative context, see Validated Monad.

• EitherExample.java

// Success case
Either<String, Integer> success = Either.right(123);

// Failure case
Either<String, Integer> failure = Either.left("File not found");

// Null values are permitted in Left or Right by default in this implementation
Either<String, Integer> rightNull = Either.right(null);
Either<String, Integer> leftNull = Either.left(null);

• EitherExample.java

  • isLeft(): Returns true if it's a Left, false otherwise.
  • isRight(): Returns true if it's a Right, false otherwise.

  if (success.isRight()) {
      System.out.println("It's Right!");
  }
  if (failure.isLeft()) {
      System.out.println("It's Left!");
  }
  

• EitherExample.java

  • getLeft(): Returns the value if it's a Left, otherwise throws NoSuchElementException.
  • getRight(): Returns the value if it's a Right, otherwise throws NoSuchElementException.

    try {
      Integer value = success.getRight(); // Returns 123
      String error = failure.getLeft();  // Returns "File not found"
      // String errorFromSuccess = success.getLeft(); // Throws NoSuchElementException
    } catch (NoSuchElementException e) {
      System.err.println("Attempted to get the wrong side: " + e.getMessage());
    }
  

• EitherExample.java

• The fold method is the safest way to handle both cases by providing two functions: one for the Left case and one for the Right case. It returns the result of whichever function is applied.

  String resultMessage = failure.fold(
      leftValue -> "Operation failed with: " + leftValue,  // Function for Left
      rightValue -> "Operation succeeded with: " + rightValue // Function for Right
  );
  // resultMessage will be "Operation failed with: File not found"
  
  String successMessage = success.fold(
      leftValue -> "Error: " + leftValue,
      rightValue -> "Success: " + rightValue
  );
  // successMessage will be "Success: 123"
  

• EitherExample.java

Applies a function only to the Right value, leaving a Left unchanged. This is known as being "right-biased".

  Function<Integer, String> intToString = Object::toString;

  Either<String, String> mappedSuccess = success.map(intToString); // Right(123) -> Right("123")
  Either<String, String> mappedFailure = failure.map(intToString); // Left(...) -> Left(...) unchanged

  System.out.println(mappedSuccess); // Output: Right(value=123)
  System.out.println(mappedFailure); // Output: Left(value=File not found)

• EitherExample.java

Applies a function that itself returns an Either to a Right value. If the initial Either is Left, it's returned unchanged. If the function applied to the Right value returns a Left, that Left becomes the result. This allows sequencing operations where each step can fail. The Left type acts as a functor that dismisses the mapped function f and returns itself (map(f) -> Left(Value)). It preserves the value it holds. After a Left is encountered, subsequent transformations via map or flatMap are typically short-circuited.

public void basicFlatMap(){

  // Example: Parse string, then check if positive
  Function<String, Either<String, Integer>> parse = s -> {
    try { return Either.right(Integer.parseInt(s.trim())); }
    catch (NumberFormatException e) { return Either.left("Invalid number"); }
  };
  Function<Integer, Either<String, Integer>> checkPositive = i ->
      (i > 0) ? Either.right(i) : Either.left("Number not positive");

  Either<String, String> input1 = Either.right(" 10 ");
  Either<String, String> input2 = Either.right(" -5 ");
  Either<String, String> input3 = Either.right(" abc ");
  Either<String, String> input4 = Either.left("Initial error");

  // Chain parse then checkPositive
  Either<String, Integer> result1 = input1.flatMap(parse).flatMap(checkPositive); // Right(10)
  Either<String, Integer> result2 = input2.flatMap(parse).flatMap(checkPositive); // Left("Number not positive")
  Either<String, Integer> result3 = input3.flatMap(parse).flatMap(checkPositive); // Left("Invalid number")
  Either<String, Integer> result4 = input4.flatMap(parse).flatMap(checkPositive); // Left("Initial error")

  System.out.println(result1);
  System.out.println(result2);
  System.out.println(result3);
  System.out.println(result4);
}