}

    public static <OUT, IN> Transformer<OUT, IN> transformer(SerializableTransformer<OUT, IN> transformer) {
        return transformer;
    }

    public static <T> Callable<T> callable(SerializableCallable<T> callable) {
        return callable;
    }

    public static <T, U, R> BiFunction<T, U, R> bifunction(SerializableBiFunction<T, U, R> f) {
        return f;
    }

        if (value == null) {
            return notDefined();
        } else {
            return of(value);
        }
    }

    public interface SerializableCallable<V> extends Callable<V>, Serializable {
    }

    public static <T> ProviderInternal<T> changing(SerializableCallable<T> value) {
        return new ChangingProvider<>(value);
    }

    public static class FixedValueProvider<T> extends AbstractProviderWithValue<T> {

public abstract class AbstractUserInputHandler implements UserInputHandler {
    @Override
    public <T> Provider<T> askUser(Function<? super UserQuestions, ? extends T> interaction) {
        return Providers.changing(new Providers.SerializableCallable<T>() {
            Try<T> result;

            @Override
            public T call() {
                if (result == null) {
                    UserInteraction questions = newInteraction();