可比较的接口叫什么?

Question

我在一个简单的链表实现在Go学习的目的。元素的定义如下:

type Element struct {
    next, prev *Element
    Value      interface{}
}

可以看到，Value可以是满足空接口的任何值。现在，作为一个新特性，我想这样做，当你向列表中插入一个新元素时，它会以一种排序的方式插入它——每个元素将是<=下一个。

为了做到这一点，我编写了以下方法:

func (l *LinkedList) Add(val interface{}) *Element {
    this := &l.Root
    e := Element{Value: val}
    for {
        if this.next.Value != nil && this.next.Value < val {  // <-comparison here
            this = this.next
        } else {
            return l.insert(&e, this)
        }
    }
}

编译器报错operator < not defined on interface，这是公平的。因此，我理解在我的Element typedef中，我应该将Value限制为可以使用<操作符进行比较的类型。我在研究这个问题时了解到Go不支持运算符重载-我并没有尝试这样做。相反，我只是试图确保元素。Value是可以使用<操作符进行比较的类型。我该怎么做呢?

更新:

我突然想到，简单地定义一个基于内置类型的新类型，可以通过某些函数进行比较，可能并不太难。所以我写了这个乱七八糟的(以及一堆其他尝试做同样事情的方法):

type Comparable interface {
    LessThan(j interface{}) bool // tried (j Comparable), (j MyInt), etc
    EqualTo(j interface{}) bool  // tried (j Comparable), (j MyInt), etc
}
type MyInt int
func (i MyInt) LessThan(j MyInt) bool {
    return i < j
}
func (i MyInt) EqualTo(j MyInt) bool {
    return i == j
}
type Element struct {
    next, prev *Element
    Value      Comparable
}

我真正想要的是定义一个接口，如果为类型实现，则提供在该类型的两个实例上操作的函数LessThan和EqualTo，并提供bool -类似LessThan(i, j WhatEvers) bool的东西，可以用来代替<。我意识到下面它被实现为一个实例方法-我已经尝试了两种方法，但没有成功。对于上面的代码，我将在Add函数中使用this.next.Value.LessThan(val)。我得到:

linkedlist.MyInt does not implement linkedlist.Comparable (wrong type for EqualTo method)
    have EqualTo(linkedlist.MyInt) bool
    want EqualTo(interface {}) bool

或

linkedlist.MyInt does not implement linkedlist.Comparable (wrong type for EqualTo method)
    have EqualTo(linkedlist.MyInt) bool
    want EqualTo(linkedlist.Comparable) bool

是否可以使用接口来要求某个函数必须存在，并且该函数必须操作自定义类型的两个实例，或者仅适用于方法?

Answer 1

编辑:
考虑以下用户类型:

type userType struct {
    frequency int
    value     rune
}

，假设你想把这些类型添加到链表中:
并且应该首先按频率排序，然后如果频率相同，则查看char值。因此Compare函数将为:

func (a userType) Compare(b userType) int {
    if a.frequency > b.frequency {
        return 1
    }
    if a.frequency < b.frequency {
        return -1
    }
    if a.value > b.value {
        return 1
    }
    if a.value < b.value {
        return -1
    }
    return 0
}

满足这个接口:

type Comparer interface {
    Compare(b userType) int
}

现在将这些{1,'d'} {2,'b'} {3,'c'} {4,'a'} {4,'b'} {4,'c'}类型添加到链接列表:
示例代码:

package main
import (
    "container/list"
    "fmt"
)
type Comparer interface {
    Compare(b userType) int
}
type userType struct {
    frequency int
    value     rune
}
// it should sort by frequency first, then if the frequencies are the same, look at the char value.
func (a userType) Compare(b userType) int {
    if a.frequency > b.frequency {
        return 1
    }
    if a.frequency < b.frequency {
        return -1
    }
    if a.value > b.value {
        return 1
    }
    if a.value < b.value {
        return -1
    }
    return 0
}
func Insert(val userType, l *list.List) {
    e := l.Front()
    if e == nil {
        l.PushFront(val)
        return
    }
    for ; e != nil; e = e.Next() {
        var ut userType = e.Value.(userType)
        if val.Compare(ut) < 0 {
            l.InsertBefore(val, e)
            return
        }
    }
    l.PushBack(val)
}
func main() {
    l := list.New()
    Insert(userType{4, 'c'}, l)
    Insert(userType{4, 'a'}, l)
    Insert(userType{4, 'b'}, l)
    Insert(userType{2, 'b'}, l)
    Insert(userType{3, 'c'}, l)
    Insert(userType{1, 'd'}, l)
    for e := l.Front(); e != nil; e = e.Next() {
        ut := e.Value.(userType)
        fmt.Printf("{%d,%q} ", ut.frequency, ut.value)
    }
    fmt.Println()
    var t interface{} = userType{4, 'c'}
    i, ok := t.(Comparer)
    fmt.Println(i, ok)
}

和输出:

{1,'d'} {2,'b'} {3,'c'} {4,'a'} {4,'b'} {4,'c'} 
{4 99} true

---

因此，如果您准备使用已知类型(例如int)，请参阅以下示例:

package main
import (
    "container/list"
    "fmt"
)
func Insert(val int, l *list.List) {
    e := l.Front()
    if e == nil {
        l.PushFront(val)
        return
    }
    for ; e != nil; e = e.Next() {
        v := e.Value.(int)
        if val < v {
            l.InsertBefore(val, e)
            return
        }
    }
    l.PushBack(val)
}
func main() {
    l := list.New()
    Insert(4, l)
    Insert(2, l)
    Insert(3, l)
    Insert(1, l)
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ") // 1 2 3 4
    }
    fmt.Println()
}

---

旧

:

在Go中没有这样的接口。您可以编写Less函数来比较您的类型:

func Less(a, b interface{}) bool {
    switch a.(type) {
    case int:
        if ai, ok := a.(int); ok {
            if bi, ok := b.(int); ok {
                return ai < bi
            }
        }
    case string:
        if ai, ok := a.(string); ok {
            if bi, ok := b.(string); ok {
                return ai < bi
            }
        }
    // ...
    default:
        panic("Unknown")
    }
    return false
}

测试示例代码:

package main
import (
    "container/list"
    "fmt"
)
func Less(a, b interface{}) bool {
    switch a.(type) {
    case int:
        if ai, ok := a.(int); ok {
            if bi, ok := b.(int); ok {
                return ai < bi
            }
        }
    case string:
        if ai, ok := a.(string); ok {
            if bi, ok := b.(string); ok {
                return ai < bi
            }
        }
    default:
        panic("Unknown")
    }
    return false
}
func Insert(val interface{}, l *list.List) *list.Element {
    e := l.Front()
    if e == nil {
        return l.PushFront(val)
    }
    for ; e != nil; e = e.Next() {
        if Less(val, e.Value) {
            return l.InsertBefore(val, e)
        }
    }
    return l.PushBack(val)
}
func main() {
    l := list.New()
    Insert(4, l)
    Insert(2, l)
    Insert(3, l)
    Insert(1, l)
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ")
    }
    fmt.Println()
    Insert("C", l)
    Insert("A", l)
    Insert("AB", l)
    Insert("C", l)
    Insert("C2", l)
    Insert("C1", l)
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ")
    }
    fmt.Println()
}

输出:

1 2 3 4 
1 2 3 4 A AB C C C1 C2 

Answer 2

这是一个可能的答案，我已经能够使工作，但它是如此丑陋，(减少每一个比较int值-可能工作的字符串，但将是血腥的其他类型的困难)-我不想接受它:

type MyInt int
type Valuer interface {
    ValueOf() int
}
func LessThan(i, j Valuer) bool {
    return i.ValueOf() < j.ValueOf()
}
func EqualTo(i, j Valuer) bool {
    return i.ValueOf() == j.ValueOf()
}
func (i MyInt) ValueOf() int {
    return int(i)
}
type Element struct {
    next, prev *Element
    Value      Valuer
}

请告诉我有更好的方法!