Optional improvements

Optionals.java

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

/**
 * @author jtakvorian
 */
public final class Optionals {

    private Optionals() {
    }

	public static <T> ThenPresent<T> ifPresent(final Optional<T> opt) {
		return executeThen -> {
			opt.ifPresent(executeThen);
			return executeElse -> {
				if (!opt.isPresent()) {
					executeElse.run();
				}
			};
		};
	}

	public static <T> ThenAbsent<T> ifAbsent(final Optional<T> opt) {
		return executeThen -> {
			if (!opt.isPresent()) {
				executeThen.run();
			}
			return opt::ifPresent;
		};
	}

	public interface ThenPresent<T> {
		ElseAbsent then(final Consumer<T> execute);
	}

	public interface ThenAbsent<T> {
		ElsePresent<T> then(final Runnable execute);
	}

	public interface ElsePresent<T> {
		void _else(final Consumer<T> execute);
	}

	public interface ElseAbsent {
		void _else(final Runnable execute);
	}
}

OptionalsTest.java

import static org.assertj.core.api.Assertions.assertThat;

import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;

import org.junit.Test;

/**
 * @author jtakvorian
 */
public class OptionalsTest {

	@Test
	public void shouldRunThenIfPresent() {
		final Optional<Integer> someInt = Optional.of(5);
		final AtomicInteger toBeSet = new AtomicInteger();
		Optionals.ifPresent(someInt)
				.then(toBeSet::set)
				._else(() -> toBeSet.set(10));
		assertThat(toBeSet.get()).isEqualTo(5);
	}

	@Test
	public void shouldRunElseIfNotPresent() {
		final Optional<Integer> someInt = Optional.empty();
		final AtomicInteger toBeSet = new AtomicInteger();
		Optionals.ifPresent(someInt)
				.then(toBeSet::set)
				._else(() -> toBeSet.set(10));
		assertThat(toBeSet.get()).isEqualTo(10);
	}

	@Test
	public void shouldRunThenIfAbsent() {
		final Optional<Integer> someInt = Optional.of(5);
		final AtomicInteger toBeSet = new AtomicInteger();
		Optionals.ifAbsent(someInt)
				.then(() -> toBeSet.set(10))
				._else(toBeSet::set);
		assertThat(toBeSet.get()).isEqualTo(5);
	}

	@Test
	public void shouldRunElseIfNotAbsent() {
		final Optional<Integer> someInt = Optional.empty();
		final AtomicInteger toBeSet = new AtomicInteger();
		Optionals.ifAbsent(someInt)
				.then(() -> toBeSet.set(10))
				._else(toBeSet::set);
		assertThat(toBeSet.get()).isEqualTo(10);
	}
}