可比较的接口叫什么？

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 不支持运算符重载的问题时了解到这一点——我并不想这样做。相反，我只是想确保 Element.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'} 类型添加到 LinkeList：
示例代码：

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
}

谁有更好的方法请告诉我！

可比较的接口叫什么？

What is the comparable interface called?

go

interface

linked-list

comparison-operators

更新：