Validation.java

import com.google.common.base.Optional;

public abstract class Validation<E, T> {

    // avoid subclasses outside of this class
    private Validation() {}

    public abstract boolean isSuccess();
    public abstract Optional<T> toOptional();
    public abstract Validation<T, E> swap();
    
    public boolean isFailure() { return !isSuccess(); }
    public T getOrNull() { return toOptional().orNull(); }

    public static <E> Success<E, Void> success() {
        return success(null);
    }

    public static <E, T> Success<E, T> success(T value) {
        return new Success<E, T>() {
            @Override
            public Optional<T> toOptional() {
                if (value == null) return Optional.of((T) new Object());
                return Optional.of(value);
            }

            @Override
            public Failure<T, E> swap() {
                return failure(value);
            }

            @Override
            public String toString() {
                return "Validation.success(" + String.valueOf(value) + ")";
            }
        };
    }

    public static <E, T> Failure<E, T> failure(E error) {
        return new Failure<E, T>() {
            @Override
            public Optional<T> toOptional() {
                return Optional.absent();
            }

            @Override
            public Success<T, E> swap() {
                return success(error);
            }

            @Override
            public String toString() {
                return "Validation.failure(" + String.valueOf(error) + ")";
            }
        };
    }

    public static abstract class Success<E, T> extends Validation<E, T> {
        private Success() {}

        @Override
        public boolean isSuccess() { return true; }
    }

    public static abstract class Failure<E, T> extends Validation<E, T> {
        private Failure() {}

        @Override
        public boolean isSuccess() { return false; }
    }

}