public static <T extends Collection<ExcludeSpec>> ExcludeSpec optimizeCollection(ExcludeFactory factory, T specs, Function<T, ExcludeSpec> onMiss) {
        if (specs.isEmpty()) {
            return factory.nothing();
        }
        if (specs.size() == 1) {
            return specs.iterator().next();
        }
        return onMiss.apply(specs);
    }

     */
    boolean applies(ExcludeSpec left, ExcludeSpec right);

    /**
     * Simplifies 2 given exclude specs (an any order) into a single exclude spec.
     *
     * @param left an exclude spec
     * @param right another exclude spec
     * @param factory the factory that can be used to create a new exclude spec

		}
		for j := 0; j < len(gen.Specs); j++ {
			spec := gen.Specs[j]
			impspec := spec.(*ast.ImportSpec)
			if importName(impspec) != name || importPath(impspec) != path {
				continue
			}

			// We found an import spec that imports path.
			// Delete it.
			delspecs = append(delspecs, impspec)
			deleted = true
			copy(gen.Specs[j:], gen.Specs[j+1:])
			gen.Specs = gen.Specs[:len(gen.Specs)-1]

        finalizeSpec(builder)
        def specification = builder.build()

        if (specs.any { it.displayName == specification.displayName }) {
            throw new IllegalStateException("Multiple specifications with display name '${specification.displayName}.")
        }
        specs << specification
    }

    protected void defaultSpec(BuildExperimentSpec.Builder builder) {

	if len(service.Spec.LoadBalancerSourceRanges) > 0 {
		specs := service.Spec.LoadBalancerSourceRanges
		ipnets, err = utilnet.ParseIPNets(specs...)

		if err != nil {
			return nil, fmt.Errorf("service.Spec.LoadBalancerSourceRanges: %v is not valid. Expecting a list of IP ranges. For example, 10.0.0.0/24. Error msg: %v", specs, err)
		}
	} else {

import org.gradle.api.internal.file.RelativePathSpec;
import org.gradle.api.internal.file.pattern.PatternMatcher;
import org.gradle.api.internal.file.pattern.PatternMatcherFactory;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.file.excludes.FileSystemDefaultExcludesListener;
import org.gradle.internal.service.scopes.Scope;

	// Write out all arguments.
	spec := w.specs[e.Ev]
	for _, arg := range e.Args[:len(spec.Args)] {
		w.buf = binary.AppendUvarint(w.buf, arg)
	}
	if spec.IsStack {
		frameArgs := e.Args[len(spec.Args):]
		for i := 0; i < len(frameArgs); i++ {
			w.buf = binary.AppendUvarint(w.buf, frameArgs[i])
		}
	}

	// Write out the length of the data.
	if spec.HasData {

        def spec = new Spec<CharSequence>() {
            boolean isSatisfiedBy(CharSequence element) {
                return false
            }
        }

        container.add("a")

        expect:
        container.matching(spec).empty
    }

    def canGetFilteredCollectionContainingAllObjectsWhichMeetSpec() {
        def spec = new Spec<CharSequence>() {

        return filtered(createFilter(type));
    }

    @Override
    public PluginCollection<T> matching(Spec<? super T> spec) {
        return filtered(createFilter(spec));
    }

    @Override
    public PluginCollection<T> matching(Closure spec) {
        return matching(Specs.<T>convertClosureToSpec(spec));
    }

    @Override
    public Action<? super T> whenPluginAdded(Action<? super T> action) {

import groovy.lang.Closure;
import org.gradle.api.specs.AndSpec;
import org.gradle.api.specs.CompositeSpec;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.internal.ClosureSpec;
import org.gradle.internal.Cast;

import javax.annotation.Nullable;

/**
 * A {@link CompositeSpec} that requires all component specs to provide a description.
 * The aggregation is based on an {@link AndSpec}.
 *