在Go语言中设计和实现通用算法：基于接口的抽象与实践

import "sort"

// algoContainer 接口定义了通用算法所需的所有能力。
// 它嵌入了 sort.Interface，并额外增加了 Copy 方法。
type algoContainer interface {
    sort.Interface // 包含 Len(), Swap(i, j int), Less(i, j int) bool
    Copy() algoContainer // 用于创建当前容器的副本
}

// sortableString 是一个字节切片，用于表示可排序的字符串。
type sortableString []byte

// Len 返回字符串的长度。
func (s sortableString) Len() int { return len(s) }

// Swap 交换指定索引位置的字节。
func (s sortableString) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

// Less 比较指定索引位置的字节大小。
func (s sortableString) Less(i, j int) bool { return s[i] < s[j] }

// Copy 创建并返回当前 sortableString 的一个副本。
func (s sortableString) Copy() algoContainer {
    // 使用 append 技巧创建新的切片并复制内容
    return append(sortableString{}, s...)
}

// String 方法用于方便地打印 sortableString。
func (s sortableString) String() string { return string(s) }

// sortable3Ints 是一个固定大小的整型数组。
type sortable3Ints [3]int

// Len 返回数组的长度。
func (sortable3Ints) Len() int { return 3 } // 对于固定大小数组，长度是常量

// Swap 交换指定索引位置的整数。注意使用指针接收者以修改原数组。
func (s *sortable3Ints) Swap(i, j int) {
    (*s)[i], (*s)[j] = (*s)[j], (*s)[i]
}

// Less 比较指定索引位置的整数大小。
func (s sortable3Ints) Less(i, j int) bool { return s[i] < s[j] }

// Copy 创建并返回当前 sortable3Ints 的一个副本。
// 注意返回的是副本的地址，因为接口方法返回的是接口类型。
func (s sortable3Ints) Copy() algoContainer { c := s; return &c }

// Algo 是一个通用算法函数，它接受任何实现了 algoContainer 接口的类型。
// 它在一个新的 goroutine 中处理数据，并将结果通过通道返回。
func Algo(list algoContainer) chan algoContainer {
    n := list.Len()
    out := make(chan algoContainer)
    go func() {
        for i := 0; i < n; i++ {
            // 复制原始数据以避免修改。
            result := list.Copy()
            // 实际的算法逻辑：如果最后一个元素小于第一个元素，则交换它们。
            if result.Less(n-1, 0) {
                result.Swap(n-1, 0)
            }
            out <- result // 将处理后的结果发送到通道
        }
        close(out) // 关闭通道表示所有结果已发送
    }()
    return out
}

package main

import (
    "fmt"
    "sort"
)

func main() {
    // 使用 sortableString 类型
    s1 := sortableString("abc")
    c1 := Algo(s1)
    fmt.Printf("Original: %s, Processed: %s\n", s1, <-c1) // 输出 Original: abc, Processed: cba

    // 使用 sortable3Ints 类型
    s2 := sortable3Ints([3]int{1, 2, 3})
    c2 := Algo(&s2) // 注意：对于 sortable3Ints，需要传入其地址，因为其 Swap 和 Copy 方法使用指针接收者
    fmt.Printf("Original: %v, Processed: %v\n", s2, <-c2) // 输出 Original: [1 2 3], Processed: [3 2 1]
}

// algoContainer 接口定义了通用算法所需的所有能力。
type algoContainer interface {
    sort.Interface
    Copy() algoContainer
}

// sortableString 类型及其方法实现
type sortableString []byte
func (s sortableString) Len() int { return len(s) }
func (s sortableString) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s sortableString) Less(i, j int) bool { return s[i] < s[j] }
func (s sortableString) Copy() algoContainer {
   return append(sortableString{}, s...)
}
func (s sortableString) String() string { return string(s) }

// sortable3Ints 类型及其方法实现
type sortable3Ints [3]int
func (sortable3Ints) Len() int { return 3 }
func (s *sortable3Ints) Swap(i, j int) {
   (*s)[i], (*s)[j] = (*s)[j], (*s)[i]
}
func (s sortable3Ints) Less(i, j int) bool { return s[i] < s[j] }
func (s sortable3Ints) Copy() algoContainer { c := s; return &c }

// Algo 是一个通用算法函数，它接受任何实现了 algoContainer 接口的类型。
func Algo(list algoContainer) chan algoContainer {
    n := list.Len()
    out := make(chan algoContainer)
    go func () {
        for i := 0; i < n; i++ {
            result := list.Copy()
            // 实际的算法逻辑：如果最后一个元素小于第一个元素，则交换它们。
            if result.Less(n-1, 0) {
                result.Swap(n-1, 0)
            }
            out <- result
        }
        close(out)
    }()
    return out
}