Go语言中标准函数式编程原语的实现与考量

package main

import "fmt"

// MapInts 示例：将整数切片中的每个元素翻倍
func MapInts(numbers []int, fn func(int) int) []int {
    result := make([]int, len(numbers))
    for i, n := range numbers {
        result[i] = fn(n)
    }
    return result
}

// FilterStrings 示例：过滤字符串切片，只保留长度大于3的字符串
func FilterStrings(strs []string, fn func(string) bool) []string {
    var result []string
    for _, s := range strs {
        if fn(s) {
            result = append(result, s)
        }
    }
    return result
}

func main() {
    // 整数切片映射示例
    nums := []int{1, 2, 3, 4, 5}
    doubledNums := MapInts(nums, func(n int) int {
        return n * 2
    })
    fmt.Println("Doubled numbers:", doubledNums) // Output: Doubled numbers: [2 4 6 8 10]

    // 字符串切片过滤示例
    words := []string{"apple", "banana", "cat", "dog", "elephant"}
    longWords := FilterStrings(words, func(s string) bool {
        return len(s) > 3
    })
    fmt.Println("Long words:", longWords) // Output: Long words: [apple banana elephant]
}

package main

import "fmt"

// Map 函数：将切片中的每个元素通过函数转换后返回新切片
// S 是源切片的元素类型，T 是目标切片的元素类型
func Map[S, T any](slice []S, fn func(S) T) []T {
    result := make([]T, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

// Filter 函数：根据谓词函数过滤切片元素，返回新切片
// S 是切片的元素类型
func Filter[S any](slice []S, fn func(S) bool) []S {
    var result []S
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

// Reduce 函数（Fold）：将切片元素逐步聚合成一个值
// S 是切片的元素类型，T 是累积结果的类型
func Reduce[S, T any](slice []S, initial T, fn func(T, S) T) T {
    accumulator := initial
    for _, v := range slice {
        accumulator = fn(accumulator, v)
    }
    return accumulator
}

func main() {
    // 使用泛型 Map 转换整数切片
    nums := []int{1, 2, 3, 4, 5}
    doubledNums := Map(nums, func(n int) int {
        return n * 2
    })
    fmt.Println("Doubled numbers (generic):", doubledNums) // Output: Doubled numbers (generic): [2 4 6 8 10]

    // 使用泛型 Map 转换字符串切片（例如，转为大写）
    words := []string{"hello", "world", "go"}
    upperWords := Map(words, func(s string) string {
        return fmt.Sprintf("%s!", s) // 示例：每个单词后加感叹号
    })
    fmt.Println("Upper words (generic):", upperWords) // Output: Upper words (generic): [hello! world! go!]

    // 使用泛型 Filter 过滤字符串切片
    allWords := []string{"apple", "banana", "cat", "dog", "elephant"}
    longWords := Filter(allWords, func(s string) bool {
        return len(s) > 3
    })
    fmt.Println("Long words (generic):", longWords) // Output: Long words (generic): [apple banana elephant]

    // 使用泛型 Reduce 计算整数切片之和
    sum := Reduce(nums, 0, func(acc int, n int) int {
        return acc + n
    })
    fmt.Println("Sum of numbers (generic):", sum) // Output: Sum of numbers (generic): 15

    // 使用泛型 Reduce 连接字符串切片
    combinedString := Reduce(words, "", func(acc string, s string) string {
        return acc + " " + s
    })
    fmt.Println("Combined string (generic):", combinedString) // Output: Combined string (generic):  hello world go
}