unfiltered.put("horse", 5);
    Predicate<Entry<?, ?>> predicate =
        new Predicate<Entry<?, ?>>() {
          @Override
          public boolean apply(Entry<?, ?> input) {
            return "cat".equals(input.getKey()) || Integer.valueOf(2) == input.getValue();
          }
        };
    Map<String, Integer> filtered = Maps.filterEntries(unfiltered, predicate);

import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.function.Predicate;

public interface IoPredicate<T> {
    boolean test(T t) throws IOException;

    static <T> Predicate<T> wrap(IoPredicate<T> predicate) {
        return t -> {
            try {
                return predicate.test(t);
            } catch (IOException e) {
                throw new UncheckedIOException(e);

    }

    @Override
    public Set<String> getLinkNames(Predicate<? super MutableModelNode> predicate) {
        return target == null ? Collections.<String>emptySet() : target.getLinkNames(predicate);
    }

    @Override
    public Set<String> getLinkNames() {
        return target == null ? Collections.<String>emptySet() : target.getLinkNames();
    }

    @Nullable

 */
abstract class ModelBinding {

    final BindingPredicate predicate;
    final ModelRuleDescriptor referrer;
    final boolean writable;
    protected ModelNodeInternal boundTo;

    protected ModelBinding(ModelRuleDescriptor referrer, BindingPredicate predicate, boolean writable) {
        this.predicate = predicate;
        this.referrer = referrer;
        this.writable = writable;
    }

    /**

    public PathBinderCreationListener(ModelRuleDescriptor descriptor, BindingPredicate predicate, boolean writable, Action<ModelBinding> bindAction) {
        super(descriptor, predicate, writable);
        this.bindAction = bindAction;
    }

    @Override
    public boolean canBindInState(ModelNode.State state) {
        return predicate.getReference().isUntyped() || state.isAtLeast(ModelNode.State.Discovered);
    }

    @Override

        Spec<? super BuildOperationRecord> predicate = Specs.SATISFIES_ALL,
        Spec<? super BuildOperationRecord> progressPredicate = Specs.SATISFIES_ALL
    ) {
        operations.roots.each { debugOpTree(it, 0, predicate, progressPredicate) }
    }

    private void debugOpTree(
        BuildOperationRecord op,
        int level,
        Spec<? super BuildOperationRecord> predicate,

    onlyIf("publishing binary to the external repository, or binary and sources to the internal one") {
        predicate.get()
    }
}
tasks.withType(PublishToMavenLocal) {
    def predicate = provider {
        publication == publishing.publications.binaryAndSources
    }
    onlyIf("publishing binary and sources") {
        predicate.get()
    }
}
// end::task-config[]

// tag::shorthand-tasks[]

import java.util.function.Predicate;

/**
 * A feature of a cache-like storage that provides an ability to invalidate the items matching a predicate.
 * @param <T> the type of the stored items.
 */
public interface ConditionalInvalidation<T> {
    /**
     * Instructs the cache to drop the stored items matching the predicate.
     */
    void invalidateItemsMatching(Predicate<T> predicate);

        }

        @Override
        Iterable<? extends MutableModelNode> getLinks(Predicate<? super MutableModelNode> predicate) {
            return null
        }

        @Override
        Set<String> getLinkNames(Predicate<? super MutableModelNode> predicate) {
            return null
        }

        @Override
        Set<String> getLinkNames() {
            []
        }

    }

    @Override
    public boolean test(JvmInstallationMetadata metadata) {
        Predicate<JvmInstallationMetadata> predicate = languagePredicate().and(vendorPredicate()).and(this::implementationTest);
        return predicate.test(metadata);
    }

    private Predicate<JvmInstallationMetadata> languagePredicate() {
        return metadata -> {