// of a func type. In this case types must match exactly: P must
// match int.

func g5[P any](func(T1[P])) {}

func _() {
	var f func(T1[int])
	g5(f)
	g5[int](f)
	g5[string](f /* ERROR "cannot use f (variable of type func(T1[int])) as func(T1[string]) value in argument to g5[string]" */)
}

// This example would fail if we were to infer the type argument int for P

  // dynamic_partition(data, partitions, num_partitions) = {
  //   [10, 20, 50],
  //   [30, 40]
  // }
  // grads = {
  //   [g1, g2, g3],
  //   [g4, g5]
  // }
  // The desired propagation of the gradients back to the data inputs is:
  // [g1, g2, g4, g5, g3]
  auto data = op.input(0);
  auto partitions = op.input(1);
  int32_t num_partitions;
  TF_RETURN_IF_ERROR(

	// Use all 16 registers to do float64 --> float32 conversion.
	g0, g1, g2, g3, g4, g5, g6, g7, g8, g9, g10, g11, g12, g13, g14, g15 :=

// Copyright 2019 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 a

var G1 int
var G2 int
var G3 int
var G4 int
var G5 int
var G6 int
var G7 int
var G8 int
var G9 int

                { "module": "m4", "version": { "requires": "v4", "prefers": "v3", "rejects": ["v5"] }, "group": "g4"},
                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                { "module": "m6", "version": { "rejects": ["v8"] }, "group": "g6"},
                { "module": "m7", "version": { "rejects": ["v7"] }, "group": "g7", "reason": "v7 is buggy"},

                { "module": "m4", "version": { "requires": "v4", "strictly": "v4a", "rejects": ["v5"] }, "group": "g4"},
                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                { "module": "m6", "version": { "rejects": ["+"] }, "group": "g6"},
                { "module": "m7", "version": { "rejects": ["v7"] }, "group": "g7", "reason": "v7 is buggy"},

var N n

type n struct{}

func (r n) M1() int  { return a.G1 }
func (r n) M2() int  { return a.G2 }
func (r n) M3() int  { return a.G3 }
func (r n) M4() int  { return a.G4 }
func (r n) M5() int  { return a.G5 }
func (r n) M6() int  { return a.G6 }
func (r n) M7() int  { return a.G7 }
func (r n) M8() int  { return a.G8 }
func (r n) M9() int  { return a.G9 }

func g3(func(int) string)                    {}
func g4[P any](func(P) string)               {}
func g5[P, Q any](func(P) string, func(P) Q) {}
func g6(func(int), func(string))             {}

func _() {
	g1(f1)
	g1(f2 /* ERROR "cannot infer P" */)
	g2(f4)
	g4(f6)
	g5(f6, f7)
	g6(f1, f1)
}

// Argument passing of partially instantiated functions
func h(func(int, string), func(string, int)) {}

        d3.name >> "m3"
        d3.versionConstraint >> requires("v3")
        d3.transitive >> true
        d3.excludeRules >> [new DefaultExcludeRule("g4", "m4"), new DefaultExcludeRule(null, "m5"), new DefaultExcludeRule("g5", null)]
        d3.attributes >> ImmutableAttributes.EMPTY

        def d4 = Stub(ExternalDependency)
        d4.group >> "g4"
        d4.name >> "m4"
        d4.versionConstraint >> requires('')

func g2[E any, S ~[]E, M ~map[string]S](m M) {}
func g3[S ~[]E, E any, M ~map[string]S](m M) {}
func g4[M ~map[string]S, E any, S ~[]E](m M) {}
func g5[E any, M ~map[string]S, S ~[]E](m M) {}

func _(m map[string][]byte) {
	g0(m)
	g1(m)
	g2(m)
	g3(m)
	g4(m)
	g5(m)
}

// Worst-case scenario.
// There are 10 unknown type parameters. In each iteration of