In Go can I use generics to declare the same method to different structs?

Is there a way to use golang 1.18 generics with struct methods? Ie something like this such that I have a common method SayName for both Foo and Bar:

package main

import (
	"fmt"
)

type Foo struct {
	Name     string
	Number   int
	FooID string
}

type Bar struct {
	Name     string
	Number   int
	BarID string
}

func  [T Foo|Bar](x *T) SayName() {
	fmt.Printf("%d \"%s\"", x.Number, x.Name)
}

func main() {
	foo := Foo{Name: "Name 1", Number: 1, FooID: "Foo123"}
	foo.SayName()

	bar := Bar{Name: "Name 2", Number: 2, BarID: "Bar456"}
	bar.SayName()
}

I know this can be done in other ways using a base type and struct embedding or interfaces on each, but this is just a contrived example to keep things simple.

UPDATE: To make this more clear, what if I have a slightly less contrived example like below. I know about struct embedding and using base interfaces. But in the case below if SayName was defined as func (b *Base) SayName() {... I would get a run time error because the Base type does not have the GetID interface (it would be nil). So I want to pass in a generic which will have this interface on the Foo and Bar instances. Am I missing something?

For instance this code below would all work if I duplicate the SayName function for each type (as seen in the commented out section)

package main

import (
	"fmt"
)

type Base struct {
	Name   string
	Number int
}

type GetIDIface interface {
	GetID() string
}

type Foo struct {
	Base
	GetIDIface
	FooID string
}

func (f *Foo) GetID() string {
	return f.FooID
}

type Bar struct {
	Base
	GetIDIface
	BarID string
}

func (b *Bar) GetID() string {
	return b.BarID
}

func  [T Foo|Bar](x *T) SayName() {
	fmt.Printf("Number %d \"%s\" with ID of %s", x.Number, x.Name, x.GetID())
}

/* THIS WORKS
func (x *Foo) SayName() {
	fmt.Printf("Number %d \"%s\" with ID of %s\n", x.Number, x.Name, x.GetID())
}

func (x *Bar) SayName() {
	fmt.Printf("Number %d \"%s\" with ID of %s\n", x.Number, x.Name, x.GetID())
}*/

func main() {
	foo := Foo{Base: Base{Name: "Name 1", Number: 1}, FooID: "Foo123"}
	foo.SayName()

	bar := Bar{Base: Base{Name: "Name 2", Number: 2}, BarID: "Bar456"}
	bar.SayName()
}

The boring and overall better solution is to declare those methods on each struct that needs them. This also makes the structs implement a hypothetical interface with SayName() method, should you need it. Beyond that, there is no language construct to declare the same method on different receivers.

What you could (but not necessarily should) do, is using a generic struct with a type constraint that restricts to Foo and Bar, however you can't access common fields of those structs. So the constraint couldn't even be Foo | Bar as we'd all like; instead you'd need methods to access those fields.

In your case you already have the GetIDIface, which Foo and Bar implement, so you can embed that:

type FooBar interface {
	Foo | Bar
	GetIDIface
}

type Base[T FooBar] struct {
	Item   T
	Name   string
	Number int
}

func (x *Base[T]) SayName() {
	fmt.Printf("Number %d \"%s\" with ID of %s\n", x.Number, x.Name, x.Item.GetID())
}

You can see the complete example in the playground.

However this reverses the relationship between Base and Foo/Bar. I.e. Base is not really a "base" anymore; it's a wrapper. Make sure it fits the semantics of your application, if you want to go down this route.

<hr>

An alternative is to use a top level function that takes an interface with the necessary functionality. This way generics aren't needed:

type Base struct {
	Name   string
	Number int
}

// Add getter on the base type itself
func (b Base) GetBase() Base {
	return b
}

type Foo struct {
	Base // embedding Base promotes GetBase() too
	FooID string
}
// other Foo methods

type Bar struct {
	Base // embedding Base promotes GetBase() too
	BarID string
}
// other Bar methods

// interface with required functionality
type Sayer interface {
	GetBase() Base
	GetIDIface
}

func SayName(x Sayer) {
	fmt.Printf("Number %d \"%s\" with ID of %s\n", x.GetBase().Number, x.GetBase().Name, x.GetID())
}

Playground: https://go.dev/play/p/4RBxW9D53Q8