How to write append "method" in go

I would like to explore Go possibilities. How would you turn "append" to method? simply: "st.app(t) == append(st, t)"
This is what I got:

type T interface{}
type ST []interface{}
func (st []T) app (t T) []T {
    return(append(st, t))
}

but this code does not check for type compatibility:

append([]int{1,2},"a") // correctly gives error 
ST{1,2}.app("a") // dumbly gives [1 2 a] !!!

I know why the code does not check for type compatibility but What is the right way to do it? Is it possible?
I appreciate your help to understand how Go works.

The right way to do this is to call append() as the built-in function it is. It's not an accident that it's a built-in function; you can't write append itself in Go, and anything that approximates it would be unsafe (and over-complicated).

Don't fight Go. Just write the line of code. In the time you spend trying to create tricky generics, you could have solved three more issues and shipped the product. That's how Go works.

This isn't to say Go will never have generics, but as we move towards Go 2 consider the following from Russ Cox:

>For example, I've been examining generics recently, but I don't have in my mind a clear picture of the detailed, concrete problems that Go users need generics to solve. As a result, I can't answer a design question like whether to support generic methods, which is to say methods that are parameterized separately from the receiver. If we had a large set of real-world use cases, we could begin to answer a question like this by examining the significant ones.

(On the other hand, Generics is the most responded-to topic in ExperienceReports, so it's not that no one is aware of the interest. But don't fight Go. It's a fantastic language for shipping great software. It is not, however, a generic language.)

4 years later, there is actually a possible solution to get methods that are parameterized separately from the receiver.

1. There is with Go 1.18 generics
2. It does not support parameterized method
3. It does support parameterized method, meaning the receiver may have type parameters
4. Jaana B. Dogan proposes "Generics facilitators in Go" based on that

> Parameterized receivers are a useful tool and helped me develop a common pattern, facilitators, to overcome the shortcomings of having no parameterized methods.
Facilitators are simply a new type that has access to the type you wished you had generic methods on.

Her example:

package database

type Client struct{ ... }

type Querier[T any] struct {
	client *Client
}

func NewQuerier[T any](c *Client) *Querier[T] {
	return &Querier[T]{
		client: c,
	}
}

func (q *Querier[T]) All(ctx context.Context) ([]T, error) {
	// implementation
}

func (q *Querier[T]) Filter(ctx context.Context, filter ...Filter) ([]T, error) {
	// implementation

You can use it as:

querier := database.NewQuerier[Person](client)

In your case though, while you could define an Appender struct, it still needs to apply on a concrete struct, which is why using the built-in append() remains preferable.

But in general, should you need parameterized methods, Jaana's pattern can help.