Golang实现泛型元组数据结构的插件库go-tuple的使用

go-tuple是一个为Go 1.18+设计的泛型元组实现库，允许你存储1到9个不同类型的值而不需要自定义结构体。

基本用法

// 创建一个包含2个元素的元组
tup := tuple.New2(5, "hi!")
fmt.Println(tup.V1) // 输出: 5
fmt.Println(tup.V2) // 输出: "hi!"

// 创建一个更长的元组
longerTuple := tuple.New5("this", "is", "one", "long", "tuple")

元组在不同场景中的应用

元组可以用作切片或数组项、映射键或值，以及通道负载：

// 映射中保存元组
tupInMap := make(map[tuple.T2[string, string]]Person)
tupInMap[tuple.New2("John", "Doe")] = Person{
    FirstName: "John",
    LastName: "Doe",
    // ...
}

// 通道中保存元组
tupInChan := make(chan tuple.T2[string, error])
go func() {
    defer close(tupInChan)
    tupInChan <- tuple.New2(os.Getwd())
}()
fmt.Print(<-tupInChan)

从函数调用创建元组

func vals() (int, string) {
    return 5, "hi!"
}

func main() {
    tup := tuple.New2(vals())
    fmt.Println(tup.V1)
    fmt.Println(tup.V2)
}

将元组作为函数参数传递

func main() {
    tup := tuple.New2(5, "hi!")
    printValues(tup.Values())
}

func printValues(a int, b string) {
    fmt.Println(a)
    fmt.Println(b)
}

访问元组值

tup := tuple.New2(5, "hi!")
a, b := tup.Values()

JSON编组

元组会被编组和解组为JSON数组：

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age,omitempty"`
}

type MyJSON struct {
    Users []tuple.T2[string, User] `json:"users"`
}

func main() {
    data := MyJSON{
        Users: []tuple.T2[string, User]{
            tuple.New2("foo", User{Name: "foo", Age: 42}),
            tuple.New2("bar", User{Name: "bar", Age: 21}),
            tuple.New2("baz", User{Name: "baz"}),
        },
    }

    marshalled, _ := json.Marshal(data)
    fmt.Printf("%s\n", string(marshalled))
    // 输出: {"users":[["foo",{"name":"foo","age":42}],["bar",{"name":"bar","age":21}],["baz",{"name":"baz"}]]}
}

比较

元组从第一个元素到最后一个元素依次比较：

fmt.Println(tuple.Equal3(tuple.New3(1, 2, 3), tuple.New3(3, 3, 3))) // false
fmt.Println(tuple.LessThan3(tuple.New3(1, 2, 3), tuple.New3(3, 2, 1))) // true

tups := []tuple.T3{
    tuple.New3("foo", 2, -23),
    tuple.New3("foo", 72, 15),
    tuple.New3("bar", -4, 43),
}
sort.Slice(tups, func (i, j int) {
    return tuple.LessThan3(tups[i], tups[j])
})

fmt.Println(tups) // [["bar", -4, 43], ["foo", 2, -23], ["foo", 72, 15]]

比较结果

// Compare*函数返回OrderedComparisonResult值
result := tuple.Compare3(tuple.New3(1, 2, 3), tuple.New3(3, 2, 1))

// OrderedComparisonResult值是包装的整数
fmt.Println(result) // -1

// OrderedComparisonResult提供了多种方法来以更可读的方式查看结果
fmt.Println(result.GreaterThan()) // false

自定义比较

type person struct {
    name string
    age  int
}

func (p person) CompareTo(guest person) tuple.OrderedComparisonResult {
    if p.name < guest.name {
        return -1
    }
    if p.name > guest.name {
        return 1
    }
    return 0
}

func main() {
    tup1 := tuple.New2(person{name: "foo", age: 20}, person{name: "bar", age: 24})
    tup2 := tuple.New2(person{name: "bar", age: 20}, person{name: "baz", age: 24})

    fmt.Println(tuple.LessThan2C(tup1, tup2)) // true
}

格式化

元组实现了Stringer和GoStringer接口：

fmt.Printf("%s\n", tuple.New2("hello", "world"))
// 输出:
// ["hello" "world"]

fmt.Printf("%#v\n", tuple.New2("hello", "world"))
// 输出:
// tuple.T2[string, string]{V1: "hello", V2: "world"}

注意事项

1. 为了比较元组，所有元组元素必须匹配constraints.Ordered
2. 元组代码和测试代码是由scripts/gen/main.go脚本生成的
3. 生成是通过使用Go的text/template引擎读取tuple.tpl和tuple_test.tpl来工作的