How to transfer interface to specified type by using generic

There is an Interface declare and many structs that implement it

type DataInterface interface {
Get(string) string
}
type DataA struct {
d map[string]string
}
func (d *DataA) Get(key string) string {
return d.d[key]
}
func (d *DataA) GetId() string {
return d.Get("id")
}
type DataB struct {
d map[string]string
}
func (d *DataB) Get(key string) string {
return d.d[key]
}
func (d *DataB) GetFile() string {
return d.Get("file")
}
type DataC...

Also includes DataC,D,E...

and I will store these DataX structs instance into a type DataSlice []DataInterface

Now, If I want to get DataX , I can do this:

type DataSlice []DataInterface
func (d DataSlice) GetA() []*DataA {
var ret []*DataA
for _, di := range d {
if v, ok := di.(*DataA); ok {
ret = append(ret, v)
}
}
return ret
}
func (d DataSlice) GetB() []*DataB {
var ret []*DataB
for _, di := range d {
if v, ok := di.(*DataB); ok {
ret = append(ret, v)
}
}
return ret
}
func (d DataSlice) GetC() .....

Obviously there's a lot of repetitive code here:

var ret []*DataX
for _, di := range d {
if v, ok := di.(*DataX); ok {
ret = append(ret, v)
}
}

So I think about that I can use generic to slove this, then I define this function:

func GetDataX[T any] (d DataInterface) *T {
return d.(*T)
}

but got error: Impossible type assertion: '*T' does not implement 'DataInterface

So, I want to know is this way really impossible? Or it could be completed by the other way?

You should be able to handle your needs with the following code:

package main

import "fmt"

// interface
type DataInterface interface {
	Get(string) string
}

// struct implementing the interface
type DataA struct {
	d map[string]string
}

func (d DataA) Get(key string) string {
	return d.d[key]
}

type DataB struct {
	d map[string]string
}

func (d DataB) Get(key string) string {
	return d.d[key]
}

type DataSlice []DataInterface

func GetDataX[T any](d DataInterface) T {
	return d.(T)
}

func main() {
	a := DataA{map[string]string{"a": "1"}}
	b := DataB{map[string]string{"b": "2"}}

	ds := DataSlice{a, b}

	for _, v := range ds {
		if value, ok := v.(DataA); ok {
			fmt.Printf("A\t%q\n", GetDataX[DataA](value))
			continue
		}

		if value, ok := v.(DataB); ok {
			fmt.Printf("B\t%q\n", GetDataX[DataB](value))
			continue
		}

		// add unknown type handling logic here
	}
}

First, I simplified the code to take into consideration only the DataA and DataB structs. Then, I changed the pointer receivers to value receivers as you're not going to change the state of the actual instance passed to the methods. Thanks to this change the GetDataX works successfully and you're able to get the info for all of your similar structs.

Let me know if this solves your issues or if you need something else, thanks!