protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context);
            Value<? extends T> value = provider.calculateValue(consumer);
            return filterValue(context, value);
        }
    }

    @Nonnull

    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            Value<? extends T> value = provider.calculateValue(consumer);
            if (value.isMissing()) {
                return Value.of(fallbackValue);
            } else {
                return value;
            }
        }
    }

        def right = Providers.of("right").withSideEffect(rightSideEffect)

        def provider = new MergeProvider([left, right]).withSideEffect(mergedSideEffect)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        provider.calculateExecutionTimeValue()

        then:
        0 * _ // no side effects when values are not unpacked

        when:

        }

        @Override
        public T calculateValue(NodeExecutionContext context) {
            return supplier.get();
        }
    }

    private static class DefaultCalculatedValueCache<K, V> implements CalculatedValueCache<K, V> {

        private final DisplayName type;
        private final Map<K, CalculatedValue<V>> cache = new ConcurrentHashMap<>();

        }

        @Override
        public ProjectInternal getOwningProject() {
            return projectState.getMutableModel();
        }

        @Override
        public File calculateValue(NodeExecutionContext context) {
            return projectState.fromMutableState(p -> projectArtifact.getFile());
        }
    }

        RegisteredBuildServiceProvider<T, ?> resolvedProvider = resolve(true);
        if (resolvedProvider == null) {
            return Value.missing();
        }
        return resolvedProvider.calculateValue(consumer);
    }

    @Nullable
    public RegisteredBuildServiceProvider<T, ?> resolveIfPossible() {
        resolve(false);
        return resolvedProvider;
    }

    @Nullable

        List<Value<? extends R>> values = new ArrayList<>(items.size());
        for (Provider<R> provider : items) {
            Value<? extends R> value = Providers.internal(provider).calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }
            values.add(value);
        }

    protected Value<? extends OUT> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context);
            Value<? extends IN> value = provider.calculateValue(consumer);
            return mapValue(context, value);
        }
    }

    @Nonnull
    protected Value<OUT> mapValue(EvaluationContext.ScopeContext context, Value<? extends IN> value) {

            for (BoundTransformStep step : steps) {
                context.add(step.getUpstreamDependencies());
            }
        }

        @Override
        public ImmutableList<Artifacts> calculateValue(NodeExecutionContext context) {
            // Isolate the transform parameters, if not already done
            for (BoundTransformStep step : steps) {
                step.getTransformStep().isolateParametersIfNotAlready();

        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> collection) {
            Value<? extends T> value = provider.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }

            collector.add(value.getWithoutSideEffect(), collection);