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> outerSup;

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

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

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

            public synchronized T get() {
                if (innerSup == null) {
                    return outerSup.get();
                } else {
                    T val = this.innerSup.get();
                    innerSup = null;
                    outerSup = () -> val;
                    return val;
                }
            }
        }

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