link:{javadocPath}/org/gradle/api/provider/Provider.html[Provider] :: Represents a value that can only be queried and cannot be changed.
** Properties with these types are read-only.
** The method link:{javadocPath}/org/gradle/api/provider/Provider.html#get--[Provider.get()] returns the current value of the property.

                input = provider { null }
                input = provider { "Hello" }
                mapInput = null
                mapInput = mapOf("a" to "b")
                mapInput = provider { null }
                mapInput = provider { mapOf("a" to "b") }
                setInput = null
                setInput = listOf("a")
                setInput = provider { null }

        'task.flatMap { it.outDir }.zip(provider { "baz" }) { d, f -> d.file(f) }' | _
        'task.get().outDir.zip(provider { "baz" }) { d, f -> d.file(f) }'          | _
        'provider { "baz" }.zip(task.flatMap { it.outDir }) { f, d -> d.file(f) }' | _
        'provider { "baz" }.zip(task.get().outDir) { f, d -> d.file(f) }'          | _
    }

    def "circular evaluation of mapped provider is detected"() {
        buildFile """

 * limitations under the License.
 */

package org.gradle.util

import org.gradle.api.internal.provider.DefaultProviderFactory
import org.gradle.api.internal.provider.Providers
import org.gradle.api.provider.Provider

public class TestProviderFactory extends DefaultProviderFactory {

    @Override
    Provider<String> environmentVariable(String variableName) {
        return Providers.ofNullable(System.getenv(variableName))

        for (Provider<R> provider : items) {
            if (isChangingValue(Providers.internal(provider))) {
                return ExecutionTimeValue.changingValue(this);
            }
        }

        return super.calculateExecutionTimeValue();
    }

    private boolean isChangingValue(ProviderInternal<?> provider) {
        return provider.calculateExecutionTimeValue().isChangingValue();
    }

        return new Collectors.TypedCollector<>(provider.getType(), new Collectors.ElementFromProvider<>(provider));
    }

    @Override
    public boolean removePending(ProviderInternal<? extends T> provider) {
        return removeByProvider(provider);
    }

    private boolean removeByProvider(ProviderInternal<?> provider) {

import org.gradle.api.configuration.BuildFeature;
import org.gradle.api.provider.Provider;

public class DefaultBuildFeature implements BuildFeature {

    private final Provider<Boolean> requested;
    private final Provider<Boolean> active;

    public DefaultBuildFeature(Provider<Boolean> requested, Provider<Boolean> active) {
        this.requested = requested;
        this.active = active;
    }

 * limitations under the License.
 */

package org.gradle.api.internal.provider

import org.gradle.api.InvalidUserCodeException
import org.gradle.api.Task
import org.gradle.api.internal.provider.CircularEvaluationSpec.CircularChainEvaluationSpec
import org.gradle.api.internal.provider.CircularEvaluationSpec.CircularFunctionEvaluationSpec
import org.gradle.api.internal.provider.CircularEvaluationSpec.UsesStringProperty

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.provider

import org.gradle.api.internal.provider.CircularEvaluationSpec.CircularFunctionEvaluationSpec
import org.gradle.api.provider.Provider
import org.gradle.internal.state.ManagedFactory

import java.util.concurrent.Callable
import java.util.function.Consumer

| `minio_cluster_replication_proxied_head_requests_total` | (_Site Replication Only_)Number of HEAD requests proxied to replication target                          |
| `minio_cluster_replication_proxied_delete_tagging_requests_total` | (_Site Replication Only_)Number of DELETE tagging requests proxied to replication target                          |