Is it possible for generic methods to only work with a subset of the typed generic?

I have a struct that I want to work with any type of number, but some of the methods will only work with floats (this is desired). Is there any way to type a method to only work with floats?

Let's say I have something like:

type Number interface {
    Integer | Float
}

type Integer interface {
    uint | uint8 | uint16 | uint32 | uint64 | int | int8 | int32 | int64
}

type Float interface {
    float32 | float64
}

I have a struct defined as:

type MyStruct[T Number] struct {
    Data []T
}

I want a method that only works for floats:

func (ms MyStruct[T]) SomeMethod() MyStruct[T] {
    result := ms.Clone()
    for i, v := range result.Data {
        result.Data[i] = helper[Float](v)
    }
    return result
}

func helper[T Float] (v T) T {
    return v*v
}

I want SomeMethod to only work if "T" is a "Float" type generic. Is this possible with generics in Go?

Or something more formal like, given that type MyStruct is instantiated with MyStruct[Float32]{} or MyStruct[float64]{}, allow caller to call "SomeMethod", otherwise, give a type error.

I am open to other ways of doing this as well, but this what I wish to do. I am writing a tensor library. I need both ints and floats, and some methods to work with just floats. I could make it work with ints, but it doesn't really make sense. I'd rather the user get an error if they try to use certain methods with ints to stray them away from it.

No, this is not possible. That’s not how generics work.

No, methods run with the same type parameter the struct is defined with. You can't specialize them, add or remove type parameters, etc.

What you can do is to write the method as a simple function instead with the struct as an argument. Then calls with structs instantiated with Integer would simply not compile.

// not a method, takes the struct as argument
func SomeMethod[T Float](ms MyStruct[T]) MyStruct[T] {
}

func main() {
	m1 := MyStruct[float64]{}
    // compiles
	SomeMethod(m1)            

	m2 := MyStruct[uint8]{}
    // doesn't compile
	SomeMethod(m2)            
}

The difference is that the generic function is instantiated at the call site (in this example) and you can supply different T's at each call, whereas the method is instantiated together with the type.

An alternative would be to inspect the concrete type of T and panic or return error if it's not one of the desired types, but this violates the principle of least surprise: if you define MyStruct[T Number] it is expected that its methods work the same with all types in Number.