Vu := optype(V.Under()) // V represents type of a result of New function, so Vu is *types.Interface bound by three methods 
	Tu := optype(T.Under()) // T represents type param I, so optype function returns types.top

func optype(typ Type) Type { 
	if t := typ.TypeParam(); t != nil { // I is a type param
		if u := t.Bound().allTypes; u != nil && u != typ { // t bound only by method list, not by type list, so allTypes is nil
			return u.Under()
		}
		return theTop // here function returns
	}
	return typ
}

func optype(typ Type) Type {
	if t := typ.TypeParam(); t != nil {
		// If the optype is typ, return the top type as we have
		// no information. It also prevents infinite recursion
		// via the TypeParam converter methods. This can happen
		// for a type parameter list of the form:
		// (type T interface { type T }).
		// See also issue #39680.
		bound := t.Bound()
		if u := bound.allTypes; u != nil && u != typ {
			// u != typ and u is a type parameter => u.Under() != typ, so this is ok
			return u.Under()
		}

		if u := bound.allMethods; u != nil  {
			return bound
		}

		return theTop
	}
	return typ
}

func curry(type
	IA, IB, RA, RB interface{},
	I Tuple(IA, IB),
	R Tuple(RA, RB),
)(a IA, fn func(t I) R) func(IB) R {
	return func(b IB) R {
		return fn(New(IA, IB)(a, b))
	}
}

package p

type Tuple interface {}

type tuple struct {}

func _(type I Tuple) () {
	var v I
	var t Tuple
	v = t // <<<< ERROR: cannot use t (variable of type Tuple) as I value in assignment
	_ = v
}