*
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#anyMatch} (same).
   */
  public final boolean anyMatch(Predicate<? super E> predicate) {
    return Iterables.any(getDelegate(), predicate);
  }

  /**
   * Returns {@code true} if every element in this fluent iterable satisfies the predicate. If this

	"istio.io/istio/pilot/pkg/model"
	"istio.io/istio/pkg/slices"
)

// FindInstance returns the first workload instance matching given predicate.
func FindInstance(instances []*model.WorkloadInstance, predicate func(*model.WorkloadInstance) bool) *model.WorkloadInstance {
	for _, instance := range instances {
		if predicate(instance) {
			return instance
		}
	}
	return nil
}

// of PRED0 and PRED1.
//
// It is tempting to call this a liveness analysis but I avoided that because
// "liveness" already has other connotations.
class DeadnessAnalysis {
 public:
  // An opaque representation of a predicate.  DeadnessPredicate
  // instances that compare equal via operator== represent predicates
  // that always evaluate to the same value.
  struct DeadnessPredicate {
   public:

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.compile.incremental.asm;

import java.util.function.Predicate;
import com.google.common.collect.ImmutableSet;

import java.util.Set;

class ClassRelevancyFilter implements Predicate<String> {

    private static final Set<String> PRIMITIVES = ImmutableSet.<String>builder()
        .add("void")
        .add("boolean")

// tag::project-with-xml[]

idea.project.ipr {
    withXml(Action<XmlProvider> {
        fun Element.firstElement(predicate: (Element.() -> Boolean)) =
            childNodes
                .run { (0 until length).map(::item) }
                .filterIsInstance<Element>()
                .first { it.predicate() }

        asElement()
            .firstElement { tagName == "component" && getAttribute("name") == "VcsDirectoryMappings" }

public class AntJacocoCheck extends AbstractAntJacocoReport<JacocoViolationRulesContainer> {

    private static final String VIOLATIONS_ANT_PROPERTY = "jacocoViolations";
    private static final Predicate<JacocoViolationRule> RULE_ENABLED_PREDICATE = new Predicate<JacocoViolationRule>() {
        @Override
        public boolean apply(JacocoViolationRule rule) {
            return rule.isEnabled();
        }
    };

		{opts: storage.ListOptions{ResourceVersion: "", Predicate: storage.SelectionPredicate{Continue: "a"}}, expectBypass: true},
		{opts: storage.ListOptions{ResourceVersion: "0", Predicate: storage.SelectionPredicate{Continue: "a"}}, expectBypass: true},
		{opts: storage.ListOptions{ResourceVersion: "1", Predicate: storage.SelectionPredicate{Continue: "a"}}, expectBypass: true},

        when: "cache gets invalidated by predicate, and some calls are made that match it and some that don't"
        metadataDetector.invalidateItemsMatching(it -> it == metadata1)
        metadataDetector.getMetadata(location1)
        metadataDetector.getMetadata(location2)
        then: "only the calls that don't match the predicate get executed again"
        1 * delegate.getMetadata(location1)

    private final Action<ModelBinding> bindAction;

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

    @Override
    public boolean canBindInState(ModelNode.State state) {

    }

    public boolean isEmpty() {
        return conflicts.isEmpty();
    }

    boolean hasMatchingConflict(Predicate<T> predicate) {
        if (isEmpty()) {
            return false;
        }
        return conflicts.stream().flatMap(conflict -> conflict.candidates.stream()).anyMatch(predicate);
    }

    class Conflict {
        final Set<K> participants;
        Collection<? extends T> candidates;