1.9.3 泛型约束与接口 #

package main

import "fmt"

// any 是最宽松的约束，等同于 interface{}
func PrintAny[T any](value T) {
    fmt.Printf("Value: %v, Type: %T\n", value, value)
}

// comparable 约束要求类型可以进行相等性比较
func Equal[T comparable](a, b T) bool {
    return a == b
}

// 自定义约束：要求类型实现 String() 方法
type Stringer interface {
    String() string
}

func PrintString[T Stringer](value T) {
    fmt.Println("String representation:", value.String())
}

// 实现 Stringer 接口的类型
type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}

func main() {
    // 使用 any 约束
    PrintAny(42)
    PrintAny("hello")
    PrintAny([]int{1, 2, 3})

    // 使用 comparable 约束
    fmt.Println("Equal integers:", Equal(10, 10))
    fmt.Println("Equal strings:", Equal("hello", "world"))

    // 使用自定义约束
    person := Person{Name: "Alice", Age: 30}
    PrintString(person)
}

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

// 使用 Ordered 约束进行排序
func BubbleSort[T constraints.Ordered](slice []T) {
    n := len(slice)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if slice[j] > slice[j+1] {
                slice[j], slice[j+1] = slice[j+1], slice[j]
            }
        }
    }
}

// 使用 Signed 约束处理有符号整数
func Abs[T constraints.Signed](value T) T {
    if value < 0 {
        return -value
    }
    return value
}

// 使用 Unsigned 约束处理无符号整数
func NextPowerOfTwo[T constraints.Unsigned](value T) T {
    if value == 0 {
        return 1
    }
    value--
    value |= value >> 1
    value |= value >> 2
    value |= value >> 4
    value |= value >> 8
    value |= value >> 16
    value |= value >> 32
    value++
    return value
}

// 使用 Integer 约束处理所有整数类型
func GCD[T constraints.Integer](a, b T) T {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

// 使用 Float 约束处理浮点数
func IsNearlyEqual[T constraints.Float](a, b, epsilon T) bool {
    diff := a - b
    if diff < 0 {
        diff = -diff
    }
    return diff < epsilon
}

func main() {
    // 排序不同类型的切片
    intSlice := []int{64, 34, 25, 12, 22, 11, 90}
    fmt.Println("Original int slice:", intSlice)
    BubbleSort(intSlice)
    fmt.Println("Sorted int slice:", intSlice)

    floatSlice := []float64{3.14, 2.71, 1.41, 1.73, 0.57}
    fmt.Println("Original float slice:", floatSlice)
    BubbleSort(floatSlice)
    fmt.Println("Sorted float slice:", floatSlice)

    stringSlice := []string{"banana", "apple", "cherry", "date"}
    fmt.Println("Original string slice:", stringSlice)
    BubbleSort(stringSlice)
    fmt.Println("Sorted string slice:", stringSlice)

    // 绝对值计算
    fmt.Println("Abs(-42):", Abs(-42))
    fmt.Println("Abs(-3.14):", Abs(-3.14))

    // 下一个2的幂
    fmt.Println("Next power of 2 after 10:", NextPowerOfTwo(uint(10)))
    fmt.Println("Next power of 2 after 15:", NextPowerOfTwo(uint(15)))

    // 最大公约数
    fmt.Println("GCD(48, 18):", GCD(48, 18))
    fmt.Println("GCD(100, 25):", GCD(100, 25))

    // 浮点数近似相等
    fmt.Println("3.14 ≈ 3.141?", IsNearlyEqual(3.14, 3.141, 0.01))
    fmt.Println("3.14 ≈ 3.15?", IsNearlyEqual(3.14, 3.15, 0.01))
}

package main

import (
    "fmt"
    "math"
)

// 定义数值运算约束
type Numeric interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
    ~float32 | ~float64
}

// 定义可序列化约束
type Serializable interface {
    Serialize() []byte
    Deserialize([]byte) error
}

// 定义可比较大小的约束
type Comparable[T any] interface {
    Compare(T) int // 返回 -1, 0, 1
}

// 使用数值约束的函数
func Sum[T Numeric](values []T) T {
    var sum T
    for _, v := range values {
        sum += v
    }
    return sum
}

func Average[T Numeric](values []T) float64 {
    if len(values) == 0 {
        return 0
    }
    sum := Sum(values)
    return float64(sum) / float64(len(values))
}

func Max[T Numeric](values []T) T {
    if len(values) == 0 {
        var zero T
        return zero
    }
    max := values[0]
    for _, v := range values[1:] {
        if v > max {
            max = v
        }
    }
    return max
}

// 实现 Comparable 接口的类型
type Version struct {
    Major, Minor, Patch int
}

func (v Version) Compare(other Version) int {
    if v.Major != other.Major {
        if v.Major > other.Major {
            return 1
        }
        return -1
    }
    if v.Minor != other.Minor {
        if v.Minor > other.Minor {
            return 1
        }
        return -1
    }
    if v.Patch != other.Patch {
        if v.Patch > other.Patch {
            return 1
        }
        return -1
    }
    return 0
}

func (v Version) String() string {
    return fmt.Sprintf("v%d.%d.%d", v.Major, v.Minor, v.Patch)
}

// 使用自定义比较约束的排序函数
func SortComparable[T Comparable[T]](slice []T) {
    n := len(slice)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if slice[j].Compare(slice[j+1]) > 0 {
                slice[j], slice[j+1] = slice[j+1], slice[j]
            }
        }
    }
}

// 定义几何形状约束
type Shape interface {
    Area() float64
    Perimeter() float64
}

// 实现 Shape 接口的类型
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

// 使用 Shape 约束的函数
func TotalArea[T Shape](shapes []T) float64 {
    var total float64
    for _, shape := range shapes {
        total += shape.Area()
    }
    return total
}

func LargestShape[T Shape](shapes []T) T {
    if len(shapes) == 0 {
        var zero T
        return zero
    }

    largest := shapes[0]
    largestArea := largest.Area()

    for _, shape := range shapes[1:] {
        if area := shape.Area(); area > largestArea {
            largest = shape
            largestArea = area
        }
    }
    return largest
}

func main() {
    // 使用数值约束
    intValues := []int{1, 2, 3, 4, 5}
    fmt.Println("Int sum:", Sum(intValues))
    fmt.Println("Int average:", Average(intValues))
    fmt.Println("Int max:", Max(intValues))

    floatValues := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
    fmt.Println("Float sum:", Sum(floatValues))
    fmt.Println("Float average:", Average(floatValues))
    fmt.Println("Float max:", Max(floatValues))

    // 使用自定义比较约束
    versions := []Version{
        {1, 2, 3},
        {2, 0, 0},
        {1, 3, 0},
        {1, 2, 4},
    }

    fmt.Println("Original versions:")
    for _, v := range versions {
        fmt.Println(" ", v)
    }

    SortComparable(versions)
    fmt.Println("Sorted versions:")
    for _, v := range versions {
        fmt.Println(" ", v)
    }

    // 使用 Shape 约束
    rectangles := []Rectangle{
        {Width: 3, Height: 4},
        {Width: 5, Height: 2},
        {Width: 1, Height: 8},
    }

    circles := []Circle{
        {Radius: 2},
        {Radius: 3},
        {Radius: 1.5},
    }

    fmt.Printf("Total rectangle area: %.2f\n", TotalArea(rectangles))
    fmt.Printf("Total circle area: %.2f\n", TotalArea(circles))

    largestRect := LargestShape(rectangles)
    fmt.Printf("Largest rectangle: %.1f x %.1f (area: %.2f)\n",
        largestRect.Width, largestRect.Height, largestRect.Area())

    largestCircle := LargestShape(circles)
    fmt.Printf("Largest circle: radius %.1f (area: %.2f)\n",
        largestCircle.Radius, largestCircle.Area())
}

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

// 联合类型约束
type SignedInteger interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

type UnsignedInteger interface {
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

type Integer interface {
    SignedInteger | UnsignedInteger
}

type Float interface {
    ~float32 | ~float64
}

type Number interface {
    Integer | Float
}

// 组合约束：既要是数字类型，又要实现 String() 方法
type StringableNumber interface {
    Number
    fmt.Stringer
}

// 自定义数字类型
type MyInt int

func (m MyInt) String() string {
    return fmt.Sprintf("MyInt(%d)", int(m))
}

type MyFloat float64

func (m MyFloat) String() string {
    return fmt.Sprintf("MyFloat(%.2f)", float64(m))
}

// 使用组合约束的函数
func ProcessStringableNumber[T StringableNumber](value T) {
    fmt.Printf("Processing %s\n", value.String())
    fmt.Printf("Value + 1 = %v\n", value+1)
}

// 更复杂的约束组合
type Addable[T any] interface {
    Add(T) T
}

type Multipliable[T any] interface {
    Multiply(T) T
}

type Arithmetic[T any] interface {
    Addable[T]
    Multipliable[T]
}

// 实现算术运算接口的向量类型
type Vector2D struct {
    X, Y float64
}

func (v Vector2D) Add(other Vector2D) Vector2D {
    return Vector2D{X: v.X + other.X, Y: v.Y + other.Y}
}

func (v Vector2D) Multiply(scalar Vector2D) Vector2D {
    return Vector2D{X: v.X * scalar.X, Y: v.Y * scalar.Y}
}

func (v Vector2D) String() string {
    return fmt.Sprintf("(%.2f, %.2f)", v.X, v.Y)
}

// 使用算术约束的函数
func Calculate[T Arithmetic[T]](a, b, c T) T {
    // 计算 (a + b) * c
    sum := a.Add(b)
    return sum.Multiply(c)
}

// 条件约束：使用类型开关
type Processor[T any] interface {
    Process() string
}

type ConditionalConstraint interface {
    constraints.Ordered | Processor[any]
}

func HandleValue[T ConditionalConstraint](value T) string {
    switch v := any(value).(type) {
    case Processor[any]:
        return v.Process()
    case constraints.Ordered:
        return fmt.Sprintf("Ordered value: %v", v)
    default:
        return fmt.Sprintf("Unknown value: %v", v)
    }
}

// 实现 Processor 接口的类型
type Task struct {
    Name string
}

func (t Task) Process() string {
    return fmt.Sprintf("Processing task: %s", t.Name)
}

// 高级约束：带有类型参数的约束
type Container[T any] interface {
    Add(T)
    Get(int) (T, bool)
    Size() int
}

type Iterable[T any] interface {
    Iterator() func() (T, bool)
}

type Collection[T any] interface {
    Container[T]
    Iterable[T]
}

// 实现 Collection 接口的切片包装器
type SliceWrapper[T any] struct {
    items []T
}

func NewSliceWrapper[T any]() *SliceWrapper[T] {
    return &SliceWrapper[T]{items: make([]T, 0)}
}

func (sw *SliceWrapper[T]) Add(item T) {
    sw.items = append(sw.items, item)
}

func (sw *SliceWrapper[T]) Get(index int) (T, bool) {
    if index < 0 || index >= len(sw.items) {
        var zero T
        return zero, false
    }
    return sw.items[index], true
}

func (sw *SliceWrapper[T]) Size() int {
    return len(sw.items)
}

func (sw *SliceWrapper[T]) Iterator() func() (T, bool) {
    index := 0
    return func() (T, bool) {
        if index >= len(sw.items) {
            var zero T
            return zero, false
        }
        item := sw.items[index]
        index++
        return item, true
    }
}

// 使用 Collection 约束的函数
func ProcessCollection[T any, C Collection[T]](collection C, processor func(T) string) []string {
    var results []string
    iterator := collection.Iterator()
    for {
        if item, ok := iterator(); ok {
            results = append(results, processor(item))
        } else {
            break
        }
    }
    return results
}

func main() {
    // 使用联合类型约束
    var si SignedInteger = int(-42)
    var ui UnsignedInteger = uint(42)
    var f Float = float64(3.14)

    fmt.Printf("Signed integer: %v\n", si)
    fmt.Printf("Unsigned integer: %v\n", ui)
    fmt.Printf("Float: %v\n", f)

    // 使用组合约束
    myInt := MyInt(42)
    myFloat := MyFloat(3.14)

    ProcessStringableNumber(myInt)
    ProcessStringableNumber(myFloat)

    // 使用算术约束
    v1 := Vector2D{X: 1, Y: 2}
    v2 := Vector2D{X: 3, Y: 4}
    v3 := Vector2D{X: 2, Y: 2}

    result := Calculate(v1, v2, v3)
    fmt.Printf("Vector calculation result: %s\n", result)

    // 使用条件约束
    fmt.Println(HandleValue(42))
    fmt.Println(HandleValue("hello"))
    fmt.Println(HandleValue(Task{Name: "Important Task"}))

    // 使用集合约束
    collection := NewSliceWrapper[string]()
    collection.Add("apple")
    collection.Add("banana")
    collection.Add("cherry")

    results := ProcessCollection(collection, func(s string) string {
        return fmt.Sprintf("Fruit: %s (length: %d)", s, len(s))
    })

    for _, result := range results {
        fmt.Println(result)
    }

    // 数字集合
    numberCollection := NewSliceWrapper[int]()
    numberCollection.Add(1)
    numberCollection.Add(2)
    numberCollection.Add(3)

    numberResults := ProcessCollection(numberCollection, func(n int) string {
        return fmt.Sprintf("Number: %d, Square: %d", n, n*n)
    })

    for _, result := range numberResults {
        fmt.Println(result)
    }
}

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

// 过于宽泛的约束
func BadExample[T any](value T) T {
    // 无法对 T 进行任何有意义的操作
    return value
}

// 过于严格的约束
func TooSpecific[T ~int](value T) T {
    return value * 2
}

// 合适的约束
func GoodExample[T constraints.Ordered](slice []T) T {
    if len(slice) == 0 {
        var zero T
        return zero
    }

    max := slice[0]
    for _, v := range slice[1:] {
        if v > max {
            max = v
        }
    }
    return max
}

// 根据需要定义约束
type Resettable interface {
    Reset()
}

type Validatable interface {
    Validate() error
}

type Entity interface {
    Resettable
    Validatable
    ID() string
}

func ProcessEntity[T Entity](entity T) error {
    entity.Reset()
    if err := entity.Validate(); err != nil {
        return fmt.Errorf("validation failed for entity %s: %w", entity.ID(), err)
    }
    return nil
}

func main() {
    // 使用合适约束的示例
    numbers := []int{3, 1, 4, 1, 5, 9, 2, 6}
    fmt.Println("Max number:", GoodExample(numbers))

    words := []string{"apple", "banana", "cherry"}
    fmt.Println("Max word:", GoodExample(words))
}

package main

import "fmt"

// 不好的做法：过度复杂的约束
type OverlyComplex[T any] interface {
    Method1() T
    Method2(T) T
    Method3(T, T) (T, error)
    Method4() []T
    Method5([]T) map[string]T
}

// 好的做法：简单明确的约束
type Reader[T any] interface {
    Read() (T, error)
}

type Writer[T any] interface {
    Write(T) error
}

type ReadWriter[T any] interface {
    Reader[T]
    Writer[T]
}

// 实现简单约束的类型
type StringBuffer struct {
    data []string
}

func (sb *StringBuffer) Read() (string, error) {
    if len(sb.data) == 0 {
        return "", fmt.Errorf("buffer is empty")
    }
    value := sb.data[0]
    sb.data = sb.data[1:]
    return value, nil
}

func (sb *StringBuffer) Write(value string) error {
    sb.data = append(sb.data, value)
    return nil
}

// 使用简单约束的函数
func Transfer[T any, R Reader[T], W Writer[T]](reader R, writer W) error {
    value, err := reader.Read()
    if err != nil {
        return err
    }
    return writer.Write(value)
}

func main() {
    buffer1 := &StringBuffer{data: []string{"hello", "world"}}
    buffer2 := &StringBuffer{}

    // 从 buffer1 转移到 buffer2
    if err := Transfer[string](buffer1, buffer2); err != nil {
        fmt.Println("Transfer error:", err)
    } else {
        fmt.Println("Transfer successful")
        if value, err := buffer2.Read(); err == nil {
            fmt.Println("Read from buffer2:", value)
        }
    }
}

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

// 设计良好的泛型函数，支持类型推断
func Clamp[T constraints.Ordered](value, min, max T) T {
    if value < min {
        return min
    }
    if value > max {
        return max
    }
    return value
}

func Map[T, U any](slice []T, mapper func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = mapper(v)
    }
    return result
}

func Filter[T any](slice []T, predicate func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

func main() {
    // 类型推断使调用更简洁
    fmt.Println("Clamped value:", Clamp(15, 10, 20))
    fmt.Println("Clamped value:", Clamp(5, 10, 20))
    fmt.Println("Clamped value:", Clamp(25, 10, 20))

    numbers := []int{1, 2, 3, 4, 5}

    // 映射：整数转字符串
    strings := Map(numbers, func(n int) string {
        return fmt.Sprintf("num_%d", n)
    })
    fmt.Println("Mapped strings:", strings)

    // 过滤：偶数
    evens := Filter(numbers, func(n int) bool {
        return n%2 == 0
    })
    fmt.Println("Even numbers:", evens)

    // 链式操作
    result := Map(
        Filter(numbers, func(n int) bool { return n > 2 }),
        func(n int) int { return n * n },
    )
    fmt.Println("Filtered and squared:", result)
}