CALCULATE_EXECUTION_TIME_VALUE("calculateExecutionTimeValue", { it.calculateExecutionTimeValue() }),
        WITH_FINAL_VALUE("withFinalValue", { it.withFinalValue(IgnoreUnsafeRead) }),
        GET_PRODUCER("getProducer", { it.getProducer() }),
        TO_STRING("toString", { it.toString() })

        private final String stringValue
        private final Consumer<ProviderInternal<?>> impl

        return Cast.uncheckedCast(List.class);
    }

    @Override
    public ValueProducer getProducer() {
        ImmutableList.Builder<ValueProducer> producers = ImmutableList.builderWithExpectedSize(items.size());
        for (Provider<R> item : items) {
            producers.add(Providers.internal(item).getProducer());
        }
        return new MergeValueProducer(producers.build());
    }

            this.left = left;
            this.right = right;
        }

        @Override
        public ValueProducer getProducer() {
            return left.getProducer().plus(right.getProducer());
        }

        @Override
        public String toString() {
            return left + " + " + right;
        }
    }

        this.valueFactory = valueFactory;
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return valueType;
    }

    @Override
    public ValueProducer getProducer() {
        // not a lambda for readability purposes.
        //noinspection Convert2Lambda
        return new ValueProducer() {
            @Override

        public InterceptingProvider(Callable<? extends T> value) {
            super(value);
        }

        @Override
        public ValueProducer getProducer() {
            calculatePresence(ValueConsumer.IgnoreUnsafeRead);
            return super.getProducer();
        }

        @Override
        public boolean calculatePresence(ValueConsumer consumer) {
            try {

    @Override
    <U, R> Provider<R> zip(Provider<U> right, BiFunction<? super T, ? super U, ? extends R> combiner) {
        throw new UnsupportedOperationException()
    }

    @Override
    ValueProducer getProducer() {
        throw new UnsupportedOperationException()
    }

    @Override
    boolean calculatePresence(ValueConsumer consumer) {
        throw new UnsupportedOperationException()
    }

    @Override

        return String.format("or(%s, %s)", left, right);
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return left.getType();
    }

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return new OrElseValueProducer(context, left, right);
        }
    }

    @Override

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        // When used as an input, add the producing tasks if known
        getProducer().visitProducerTasks(context);
    }

    @Override
    public ValueProducer getProducer() {
        return ValueProducer.unknown();
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {

    }

    @Nullable
    @Override
    public Class<T> getType() {
        return Cast.uncheckedCast(provider.getType());
    }

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return new OrElseValueProducer(context, provider);
        }
    }

    @Override

        return "file collection";
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        ValueSupplier.ValueProducer producer = provider.getProducer();
        if (producer.isKnown()) {
            producer.visitProducerTasks(context);
        } else {
            // Producer is unknown, so unpack the value