Go 如何使用通用结构

我有订单列表的结构。我想要秩序

地图
并找到它的方式。但我不想为我所有的类型创建这个。也许我需要另一个密码？或者我如何为universal重写它，我可以将它用于所有类型，包括
Prev
和
Next

type Post struct { //for example
    P string
    O int
    Prev, Next *Post
}
type Act struct {
    I int
    Prev, Next *Act
}    

type Map struct {
    Act         map[int]*Act
    First, Last *Act
}

func (m *Map) New(a *Act) int {
    Ida++
    f := Ida
    a.Id = Ida
    m.Act[Ida] = a
    if m.First == nil {
        m.First = a
    } else {
        m.Last.Next = a
        a.Prev = m.Last
    }
    m.Last = a
    return f
}

func (m *Map) Del(s int) {
    if _, ok := m.Act[s]; ok {
        if m.Last == m.First {
            m.Last = nil
            m.First = nil
            delete(m.Act, s)
            return
        }
        if m.Last == m.Act[s] {
            m.Last = m.Act[s].Prev
            m.Act[s].Prev.Next = nil
            delete(m.Act, s)
            return
        }
        if m.First == m.Act[s] {
            m.First = m.Act[s].Next
            m.Act[s].Next.Prev = nil
            delete(m.Act, s)
            return
        }
        m.Act[s].Prev.Next = m.Act[s].Next
        m.Act[s].Next.Prev = m.Act[s].Prev
        delete(m.Act, s)
        return
    }
}

您可以定义用于实现
Prev（）
和
Next（）
方法的所有类型的函数。举个例子

type List interface{
    Next() List
    Prev() List
    First() List
    Last() List
    Value() interface{}
    SetNext(List)
    SetPrev(List)
}
func Del(l List, elem_to_delete interface{}){
    for e:=l.First(); e != l.Last(); e = l.Next()
        if l.Value() == elem_to_delete{
            l.Prev().SetNext(l.Next())
            l.Next().SetPrev(l.Prev())
            break
        }
    }
}
//and implement those methods for your types
type Post struct { //for example
    P string
    O int
    Prev, Next *Post
}
func (p Post) Next() List{
    return p.Next
}
...
//and then you can call Del() with any of this types
Del(post, 5)

还可以定义列表数据结构，以便使用。
如果要将
下一步
和
上一步
操作定义为方法：

type Act struct {
    I int
    Prev, Next *Act
}

func (a *Act) GetNext(){
    return a.Next
}    

您可以有一个界面：

type PrevNext interface {
    GetNext() *Act
    GetPrev() *Act
    // ... and all other required actions
}

因此，您可以将
Del（）
定义为泛型函数，而不是方法，它期望对象为
prevenxt
类型，所有必需的操作都定义为方法

func Del(m *PrevNext, s int) {
    if _, ok := m.Act[s]; ok {
        if m.GetLast() == m.GetFirst() {
            m.SetLast(nil)
            m.SetFirst(nil)
            delete(m.Act, s)
            return
        } 
    // ....
    }
}

你不能。Go没有泛型：）@Nadh我必须重写它吗？你能回答另一个问题吗？我不使用数组进行排序，因为在需要元素之前的元素可以提前删除。我担心它会删除另一个元素