Unit.java

package dev.gabrieljones;

import io.vavr.control.Either;
import io.vavr.control.Option;
import io.vavr.control.Try;

import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public interface Unit {
  Void voidUnit = null;

  interface Thunk { void apply(); }

  static <T> Function<T, Void> voidFunction(Consumer<? super T> consumer) {
    return t -> {
      consumer.accept(t);
      return voidUnit;
    };
  }

  static <T> Function<T, Void> voidFunction() {
    return t -> voidUnit;
  }

  static <R> Supplier<Void> voidSupplier(Supplier<? super R> supplier) {
    return () -> {
      supplier.get();
      return voidUnit;
    };
  }

  static Supplier<Void> voidSupplier(Thunk thunk) {
    return () -> {
      thunk.apply();
      return voidUnit;
    };
  }

  static Supplier<Void> voidSupplier() {
    return () -> voidUnit;
  }

  static <T> void fold(
    Optional<? extends T> foldable,
    Thunk ifNone,
    Consumer<? super T> f
  ) {
    if (foldable.isEmpty()) { ifNone.apply(); } else { f.accept(foldable.get()); }
  }

  static <T> void fold(
    Option<? extends T> foldable,
    Thunk ifNone,
    Consumer<? super T> f
  ) {
    foldable.fold(
      voidSupplier(ifNone),
      voidFunction(f)
    );
  }

  static <T> void fold(
    Try<? extends T> foldable,
    Consumer<? super Throwable> ifFailure,
    Consumer<? super T> f
  ) {
    foldable.fold(
      voidFunction(ifFailure),
      voidFunction(f)
    );
  }

  static <L, R> void fold(
    Either<? extends L, ? extends R> foldable,
    Consumer<? super L> fL,
    Consumer<? super R> fR
  ) {
    foldable.fold(
      voidFunction(fL),
      voidFunction(fR)
    );
  }
}

UnitTest.java

package dev.gabrieljones;

import java.util.Optional;

public class UnitTest {
  public static void main(String[] args) {
    Unit.fold(
      Optional.empty(),
      () -> System.out.println("Empty"),
      System.out::println
    );
    Unit.fold(
      Optional.ofNullable(null),
      () -> System.out.println("Empty"),
      System.out::println
    );
    Unit.fold(
      Optional.of(42),
      () -> System.out.println("Empty"),
      System.out::println
    );
  }
}