How to make a copy by value of a generic type parameter

In a generic function, how can I copy by value a parameter with a generic type ?

Here is a minimal example :

type MyInterface interface { // Interface use for type constraint
	SetID(string)
}

type Implem struct { // Implements MyInterface
	ID string
}

func (i *Implem) SetID(id string) {
	i.ID = id
}

func doStuff[T MyInterface](input T) T {
	res := input // Here I want to make a copy of input, so the next line modify res but not input
	res.SetID("newID")
	return res
}

func main() {
	implem := &Implem{ID: "oldID"}
	res := doStuff(implem)
	fmt.Println(implem) // Should be "oldID"
	fmt.Println(res)    // Should be "newID"
}

I tried several things, like declaring res as a *T and setting input as its value, or playing with type assertions, but SetID still modify input.

What is the best way to copy input by value ?

In the general case, shallow copying type parameters works the same as with whatever type argument was used to instantiate it. If you instantiate T with a non-pointer type, an assignment copies its value. If you instantiate T with a pointer type, an assignment still copies its value, but that value is a memory address.

In the code you wrote, the type constraint MyInterface could be satisfied by both pointer and non-pointer types.

Hypothetically, you could declare a type like:

type Foo struct{}

func (i Implem) SetID(id string) {
}

Any assignment on fields of a value receiver would be ineffective, but Foo would be a valid type argument.

Perhaps what you want to do is to restrict the type parameter to pointer types. This way you can capture the base type and dereference to shallow copy the value.

// restrict to pointer types
type MyInterface[T any] interface {
	*T
	SetID(string)
}

// capture the base type T
// the argument 'input' is a pointer type due to MyInterface
func doStuff[T any, U MyInterface[T]](input U) U {
	t := *input        // dereferencing copies the value
	res := U(&t)       // take address of t and convert to U
	res.SetID("newID") // you can now call SetID on value of type U
	return res
}

And this outputs

&{oldID}
&{newID}

Playground: https://go.dev/play/p/U8Ssq3_YPVi

<hr>

As an alternative, you can add an additional method to your struct that returns a copy of it. Then within the generic function, you type assert to an anonymous interface that has that method:

// shallow copy and return same type
func (i *Implem) Copy() *Implem {
	c := *i
	return &c
}

func doStuff[T MyInterface](input T) T {
    // type assert to anonymous interface with method that returns T
	t, ok := any(input).(interface{ Copy() T })
	if !ok {
		// handle failure
	}
	res := t.Copy()
	res.SetID("newID")
	return res
}

Playground: https://go.dev/play/p/K7MOApHdEmM

Using an anonymous interface in my opinion makes it more convenient and readable, as the type parameter T is used in a self-explanatory way. You can of course define a named interface:

type Copier[T any] interface {
	Copy() T
}

and assert to that interface instantiated with T:

t, ok := any(input).(Copier[T])

Playground: https://go.dev/play/p/Berisu6Qz-P