return Providers.nullableValue(calculateValue(consumer));
    }

    @Override
    public final String toString() {
        // Override #toStringNoReentrance instead
        return EvaluationContext.current().tryEvaluate(this, "<CIRCULAR REFERENCE>", this::toStringNoReentrance);
    }

    @Override
    public boolean isImmutable() {
        return false;
    }

    @Override

        @Override
        public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
            return ExecutionTimeValue.fixedValue(value);
        }

        @Override
        protected String toStringNoReentrance() {
            return String.format("fixed(%s, %s)", getType(), value);
        }
    }

class ChangingProvider<T> extends DefaultProvider<T> {

    public <CALLABLE extends Callable<T> & Serializable> ChangingProvider(CALLABLE value) {
        super(value);
    }

    @Override
    protected String toStringNoReentrance() {
        return "changing(?)";
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        return ExecutionTimeValue.changingValue(this);
    }

    public OrElseFixedValueProvider(ProviderInternal<? extends T> provider, T fallbackValue) {
        this.provider = provider;
        this.fallbackValue = fallbackValue;
    }

    @Override
    protected String toStringNoReentrance() {
        return String.format("or(%s, fixed(%s))", provider, fallbackValue);
    }

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

    public OrElseProvider(ProviderInternal<T> left, ProviderInternal<? extends T> right) {
        this.left = left;
        this.right = right;
    }

    @Override
    protected String toStringNoReentrance() {
        return String.format("or(%s, %s)", left, right);
    }

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

    @Override

        if (sideEffect == null) {
            return this;
        }

        return of(provider, SideEffect.composite(this.sideEffect, sideEffect));
    }

    @Override
    protected String toStringNoReentrance() {
        return "" + provider + " (with side effect " + sideEffect + ")";
    }

            return backingProvider(context, ValueConsumer.IgnoreUnsafeRead).calculateExecutionTimeValue();
        }
    }

    @Override
    protected String toStringNoReentrance() {
        return "flatmap(" + provider + ")";
    }

        }
        return transformedValue;
    }

    @Override
    protected void beforeRead(EvaluationContext.ScopeContext context) {}

    @Override
    protected String toStringNoReentrance() {
        return "map(" + (type == null ? "" : type.getName() + " ") + provider + " " + transformer + ")";
    }

                );
            }
        });
    }

    @Override
    protected String toStringNoReentrance() {
        return "filter(" + (getType() == null ? "" : getType().getName() + " ") + provider + ")";
    }

        this.type = type;
        this.combiner = combiner;
        this.left = Providers.internal(left);
        this.right = Providers.internal(right);
    }

    @Override
    protected String toStringNoReentrance() {
        return String.format("and(%s, %s)", left, right);
    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext ignored = openScope()) {