if (rightValue.isMissing()) {
                return rightValue.asType();
            }

            R combinedUnpackedValue = combiner.apply(leftValue.getWithoutSideEffect(), rightValue.getWithoutSideEffect());

            return Value.ofNullable(combinedUnpackedValue)
                .withSideEffect(SideEffect.fixedFrom(leftValue))
                .withSideEffect(SideEffect.fixedFrom(rightValue));

            Value<? extends V> value = providerOfValue.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }
            collector.add(key, value.getWithoutSideEffect(), dest);
            return Value.present().withSideEffect(SideEffect.fixedFrom(value));
        }

        @Override

        @Nullable
        static <T, A> SideEffect<T> fixedFrom(Value<A> value) {
            if (value.isMissing()) {
                return null;
            }

            return fixed(value.getWithoutSideEffect(), value.getSideEffect());
        }

        /**
         * Extracts the side effect from the {@code value} if any, and fixes it on that value.
         * <p>

        if (value.isMissing()) {
            return value.asType();
        }
        T unpackedValue = value.getWithoutSideEffect();
        if (spec.isSatisfiedBy(unpackedValue)) {
            return value;
        } else {
            return Value.missing();
        }
    }

            values.add(value);
        }

        ImmutableList.Builder<R> result = ImmutableList.builderWithExpectedSize(values.size());
        for (Value<? extends R> value : values) {
            result.add(value.getWithoutSideEffect());
        }

        Value<List<R>> finalValue = Value.ofNullable(result.build());
        for (Value<? extends R> value : values) {
            finalValue = finalValue.withSideEffect(SideEffect.fixedFrom(value));

        }
    }

    private ProviderInternal<? extends S> doMapValue(@SuppressWarnings("unused") EvaluationContext.ScopeContext context, Value<? extends T> value) {
        T unpackedValue = value.getWithoutSideEffect();
        Provider<? extends S> transformedProvider = transformer.transform(unpackedValue);
        if (transformedProvider == null) {
            return Providers.notDefined();
        }

            Value<? extends T> value = provider.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }

            collector.add(value.getWithoutSideEffect(), collection);
            return Value.present().withSideEffect(SideEffect.fixedFrom(value));
        }

        @Override
        public boolean isProvidedBy(Provider<?> provider) {

                return notDefined();
            } else {
                return new NoValueProvider<>(value);
            }
        } else {
            ProviderInternal<T> provider = of(value.getWithoutSideEffect());
            ValueSupplier.SideEffect<?> sideEffect = value.getSideEffect();
            return sideEffect == null ? provider : provider.withSideEffect(Cast.uncheckedCast(sideEffect));
        }
    }

        withActualValue(it -> it.addAll(provider));
    }

    @Override
    public int size() {
        return calculateOwnPresentValue().getWithoutSideEffect().size();
    }

    /**
     * Adds the given supplier as the new root supplier for this collection.
     *
     * @param collector the collector to add

        Value<? extends Map<K, V>> result = value.calculateValue(consumer);
        if (!result.isMissing()) {
            return new FixedSupplier<>(result.getWithoutSideEffect(), uncheckedCast(result.getSideEffect()));
        } else if (result.getPathToOrigin().isEmpty()) {
            return noValueSupplier();
        } else {
            return new NoValueSupplier(result);
        }