Lazy.java

import java.util.function.Supplier;

public interface Lazy<T> extends Supplier<T> {

    static <T>  Lazy<T> of(Supplier<T> sup) {
        return new LazyImpl<T>(sup);
    }

    static <T> Lazy<T> ofSafe(Supplier<T> sup) {
        return new LazyThreadSafe<T>(sup);
    }

    class LazyImpl<T> implements Lazy<T> {
        private Supplier<T> sup;

        LazyImpl(Supplier<T> sup) {
            this.sup = () -> {
                T val = sup.get();
                this.sup = () -> val;
                return val;
            };
        }

        @Override
        public T get() {
            return sup.get();
        }
    }

    class LazyThreadSafe<T> implements Lazy<T> {
        private Supplier<T> sup;

        LazyThreadSafe(Supplier<T> sup) {
            this.sup = new UnEvaled(sup);
        }

        class UnEvaled implements Supplier<T>{
            Supplier<T> init;

            UnEvaled(Supplier<T> sup) {
                init = sup;
            }

            public synchronized T get() {
                if (sup instanceof LazyThreadSafe.UnEvaled) {
                    T val = init.get();
                    sup = () -> val;
                    return val;
                } else {
                    return sup.get();
                }
            }
        }

        @Override
        public T get() {
            return sup.get();
        }
    }
}