Because those implementations live at different GAV coordinates, the build tool has usually no way to find out that there's a conflict between those libraries.
To solve this, Gradle provides the concept of _capability_.

It's illegal to find two components providing the same _capability_ in a single dependency graph.

// This file was duplicated from the auto-generated file by conversion-gen in
// k8s.io/kubernetes/pkg/apis/apidiscovery Unlike most k8s types discovery is
// served by all apiservers and conversion is needed by all apiservers. The
// concept of internal/hub type does not exist for discovery as we work directly
// with the versioned types.

// The conversion code here facilities conversion strictly between v2beta1 and

     * <p>
     * {@link SourceSet#getOutput()} and the classpath-returning methods on the returned
     * source set should ideally be avoided in favor of the similarly-named methods on
     * this feature. The concept of source sets having a single set of outputs is only
     * relevant for single-target features.
     *
     * @return This feature's source set.
     */
    SourceSet getSourceSet();

    /**

In general script files should have short names: a few words, not whole sentences.
The first word should be the general category of behavior being tested,
often the name of a go subcommand (list, build, test, ...) or concept (vendor, pattern).

Each script is a text archive (go doc internal/txtar).
The script begins with an actual command script to run
followed by the content of zero or more supporting files to

Turning this into proper variants is a bit more tricky, as Gradle first selects a version of a module and then selects the best fitting variant.
So the concept that variants are encoded as versions is not supported directly.
However, since both variants are always published together we can assume that the files are physically located in the same repository.

It's easy to end up with a set of versions which do not work well together.
To fix this, Gradle supports dependency version alignment, which is supported by the concept of platforms.
A platform represents a set of modules which "work well together".

	r, err := zoneToRegion(loc)
	if err != nil {
		log.Warnf("Error fetching GCP region: %v", err)
		return &l
	}
	return &core.Locality{
		Region:  r,
		Zone:    loc,
		SubZone: "", // GCP has no subzone concept
	}
}

const ComputeReadonlyScope = "https://www.googleapis.com/auth/compute.readonly"

// Labels attempts to retrieve the GCE instance labels within the timeout

  <artifactId>maven-parent</artifactId>
  <version>5</version>
  <packaging>pom</packaging>
  <name>Apache Maven</name>
  <description>
    Maven is a software project management and comprehension tool. Based on the concept of a project object model
    (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.
  </description>
  <url>http://maven.apache.org/</url>
  <issueManagement>

* `fixedquery` : a pour valeur exacte `fixedquery`.
* `$` : se termine directement ensuite, n'a pas d'autres caractères après `fixedquery`.

Si vous vous sentez perdu avec le concept d'**expression régulière**, pas d'inquiétudes. Il s'agit d'une notion difficile pour beaucoup, et l'on peut déjà réussir à faire beaucoup sans jamais avoir à les manipuler.

// vhosts or routes for the inbound listener.
//
// For gateways it would make a lot of sense to use this concept, same for moving path prefix at top level ( more scalable, easier for users)
// This should probably be done for the v2 API.
//
// nolint: unparam