*/
public class TransformBackedProvider<OUT, IN> extends AbstractMinimalProvider<OUT> {

    protected final Class<OUT> type;
    protected final ProviderInternal<? extends IN> provider;
    protected final Transformer<? extends OUT, ? super IN> transformer;

    public TransformBackedProvider(
        @Nullable Class<OUT> type,
        ProviderInternal<? extends IN> provider,

 * </ul>
 *
 * <p>This implementation is used only for internal transforms where these constraints are known to be true.
 * For user provided mappings and other internal mappings, {@link TransformBackedProvider} is used instead.</p>
 *
 * <p>The constraints allows certain optimizations. Currently, this is limited to skipping the transform when the provider presence is queried, but other optimizations may be added in the future.

    private String value = "value";

    private Property<String> property;

    @Setup
    public void setUp() {
        property = new DefaultProperty<>(host, String.class);
        property.set(new TransformBackedProvider<>(String.class, new DefaultProvider<>(() -> value), v -> v + v));
    }

    @Benchmark
    public void getPropertyValue(Blackhole bh) {
        bh.consume(property.get());
    }

                @Override
                String toString() {
                    return "Transformer with $provider"
                }
            }
            transform.provider = new TransformBackedProvider(String, Providers.of("value"), transform)
            return transform.provider
        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {

        description               | wrap
        "Provider.map"            | { p, m -> p.map(m) }
        "Provider.flatMap"        | { p, m -> p.flatMap { Providers.of(m.call(it)) } }
        "TransformBackedProvider" | { p, m -> new TransformBackedProvider(null, p, m) }
        "MappingProvider"         | { p, m -> new MappingProvider(Integer, p, m) }
    }

    @Override
    public <S> ProviderInternal<S> map(final Transformer<? extends @org.jetbrains.annotations.Nullable S, ? super T> transformer) {
        // Could do a better job of inferring the type
        return new TransformBackedProvider<>(null, this, transformer);
    }

    @Override
    public ProviderInternal<T> filter(final Spec<? super T> spec) {
        return new FilteringProvider<>(this, spec);
    }

    @Override