// min can be called with explicit instantiation.

_ = min[int](1, 2)

// Alternatively, the type argument can be inferred from

// one of the arguments. Untyped arguments will be considered

// last.

var x int

_ = min(x, x)

_ = min(x, 1)

_ = min(x, 1.0)

_ = min(1, 2)

_ = min(1, 2.3)

var y float64

_ = min(1, y)

_ = min(1.2, y)

_ = min(1.2, 3.4)

_ = min(1.2, 3)

var s string

_ = min(s, "foo")

_ = min("foo", "bar")

// mixed can be called with explicit instantiation.

mixed[int, string, bool](0, "", false)

// Alternatively, partial type arguments may be provided

// (from left to right), and the other may be inferred.

mixed[int, string](0, "", false)

mixed[int](0, "", false)

mixed(0, "", false)

// Provided type arguments always take precedence over

// inferred types.

mixed[int, string](1.1 /* ERROR "cannot use 1.1" */, "", false)

// related1 can be called with explicit instantiation.

var si []int

related1[[]int, int](si, 0)

// Alternatively, the 2nd type argument can be inferred

// from the first one through constraint type inference.

var ss []string

_ = related1[[]string]

related1[[]string](ss, "foo")

// A type argument inferred from another explicitly provided

// type argument overrides whatever value argument type is given.

related1[[]string](ss, 0 /* ERROR "cannot use 0" */)

// A type argument may be inferred from a value argument

// and then help infer another type argument via constraint

// type inference.

related1(si, 0)

related1(si, "foo" /* ERROR `cannot use "foo"` */)

// related2 can be called with explicit instantiation.

var si []int

related2[int, []int](0, si)

// Alternatively, the 2nd type argument can be inferred

// from the first one through constraint type inference.

var ss []string

_ = related2[string]

related2[string]("foo", ss)

// A type argument may be inferred from a value argument

// and then help infer another type argument via constraint

// type inference. Untyped arguments are always considered

// last.

related2(1.2, []float64{})

related2(1.0, []int{})

related2 /* ERROR "Slice (type []int) does not satisfy interface{[]Elem}" */ (float64(1.0), []int{}) // TODO(gri) better error message

// related3 can be instantiated explicitly

related3[int, []int]()

related3[byte, List[byte]]()

// The 2nd type argument cannot be inferred from the first

// one because there's two possible choices: []Elem and

// List[Elem].

related3 /* ERROR "cannot infer Slice" */ [int]()

m1(Q)

m2() R

}, Q, R any](P) {

// wantsMethod can be called with arguments that have the relevant methods

// and wantsMethod's type arguments are inferred from those types' method

// signatures.

wantsMethods(hasMethods1{})

wantsMethods(&hasMethods1{})

wantsMethods /* ERROR "P (type hasMethods2) does not satisfy interface{m1(Q); m2() R} (method m1 has pointer receiver)" */ (hasMethods2{})

wantsMethods(&hasMethods2{})

wantsMethods(hasMethods3(nil))

wantsMethods /* ERROR "P (type any) does not satisfy interface{m1(Q); m2() R} (missing method m1)" */ (any(nil))

wantsMethods /* ERROR "P (type hasMethods4) does not satisfy interface{m1(Q); m2() R} (wrong type for method m1)" */ (hasMethods4(nil))