<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"

include("standardJvmRuntimeClasspathAndroid")

include("androidRuntimeClasspathAndroid")

// Enforce 'android' variant in Java projects via constraint

include("standardJvmAndroidConstraintCompileClasspathJava")

include("androidAndroidConstraintCompileClasspathJava")

// Enforce 'jre' variant in Android projects via constraint

include("standardJvmJreConstraintCompileClasspathAndroid")

// Check whether the tensor is ranked and whether its last dim is static.
def IsRankedShapeLastDimStatic : Constraint<And<[
  CPred<"$0.getType().isa<RankedTensorType>()">,
  CPred<"!$0.getType().cast<ShapedType>().isDynamicDim( "
  "  $0.getType().cast<RankedTensorType>().getRank() - 1)">]>>;

def IsNotComplexType : Constraint<And<[
  CPred<"$0.getType().isa<RankedTensorType>()">,

// all tags are both true and false at the same time.
func eval(x constraint.Expr, tags map[string]bool, prefer bool) bool {
	switch x := x.(type) {
	case *constraint.TagExpr:
		return matchTag(x.Tag, tags, prefer)
	case *constraint.NotExpr:
		return !eval(x.X, tags, !prefer)
	case *constraint.AndExpr:
		return eval(x.X, tags, prefer) && eval(x.Y, tags, prefer)
	case *constraint.OrExpr:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// A constraint must be an interface; it cannot
// be a type parameter, for instance.

    private VersionParserException parseInvalid(String constraint) {
        try {
            versionParser.parseVersionConstraint(constraint);
            fail("expected exception for constraint " + constraint);
            return null;
        } catch (VersionParserException e) {
            return e;
        }
    }

    @Test

	podLabelSet := labels.Set(updatedPod.Labels)
	for _, constraint := range s.Constraints {
		if !constraint.Selector.Matches(podLabelSet) {
			continue
		}

		if pl.enableNodeInclusionPolicyInPodTopologySpread &&
			!constraint.matchNodeInclusionPolicies(preemptorPod, node, requiredSchedulingTerm) {
			continue
		}

		k, v := constraint.TopologyKey, node.Labels[constraint.TopologyKey]
		pair := topologyPair{key: k, value: v}

// run

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type Constraint[T any] interface {
	~func() T
}

func Foo[T Constraint[T]]() T {
	var t T

	t = func() T {
		return t
	}
	return t
}

func main() {
	type Bar func() Bar
	Foo[Bar]()

            root(':', ':testproject:') {
                module("group:bom:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")
                    noArtifacts()
                }
                module("group:bom2:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")
                    noArtifacts()
                }

        // These are invalid and the type-checker will complain.
        _[~t] t
        _[~t|t] t
        _[t|~t] t
        _[~t|~t] t
)

type _[_ t, t] /* ERROR "missing type constraint" */ t
type _[_ ~t, t] /* ERROR "missing type constraint" */ t
type _[_ t, ~ /* ERROR "missing type parameter name" */ t] t
type _[_ ~t, ~ /* ERROR "missing type parameter name" */ t] t

type _[_ t|t, t /* ERROR "missing type parameter name" */ |t] t