使用hasgo为Golang切片生成Haskell风格函数

hasgo是一个为Golang切片提供Haskell风格函数式操作的库，它通过代码生成的方式为自定义切片类型添加函数式操作方法。

安装hasgo

首先安装hasgo工具：

go get github.com/DylanMeeus/hasgo

基本使用

1. 为自定义类型生成函数

创建一个包含自定义类型的go文件，例如types.go：

//go:generate hasgo -types=MySlice=int,float64
package main

type MySlice []int

然后运行go generate：

go generate

这会为MySlice类型生成函数式操作方法。

2. 常用Haskell风格函数示例

Map 操作

package main

import "fmt"

func main() {
    s := MySlice{1, 2, 3, 4}
    
    // 每个元素乘以2
    doubled := s.Map(func(i int) int {
        return i * 2
    })
    fmt.Println(doubled) // 输出: [2 4 6 8]
}

Filter 操作

func main() {
    s := MySlice{1, 2, 3, 4, 5, 6}
    
    // 过滤偶数
    evens := s.Filter(func(i int) bool {
        return i%2 == 0
    })
    fmt.Println(evens) // 输出: [2 4 6]
}

Fold (Reduce) 操作

func main() {
    s := MySlice{1, 2, 3, 4}
    
    // 求和
    sum := s.Foldl(0, func(acc, i int) int {
        return acc + i
    })
    fmt.Println(sum) // 输出: 10
}

Zip 操作

func main() {
    s1 := MySlice{1, 2, 3}
    s2 := MySlice{4, 5, 6}
    
    // 将两个切片合并为元组切片
    zipped := s1.Zip(s2)
    fmt.Println(zipped) // 输出: [{1 4} {2 5} {3 6}]
}

3. 更多函数式操作

hasgo提供了丰富的Haskell风格函数：

func main() {
    s := MySlice{1, 2, 3, 4, 5}
    
    // Take - 取前n个元素
    first3 := s.Take(3)
    fmt.Println(first3) // [1 2 3]
    
    // Drop - 丢弃前n个元素
    after2 := s.Drop(2)
    fmt.Println(after2) // [3 4 5]
    
    // Reverse - 反转切片
    reversed := s.Reverse()
    fmt.Println(reversed) // [5 4 3 2 1]
    
    // Any/All - 条件检查
    hasEven := s.Any(func(i int) bool { return i%2 == 0 })
    allPositive := s.All(func(i int) bool { return i > 0 })
    fmt.Println(hasEven, allPositive) // true true
    
    // TakeWhile/DropWhile - 条件取/丢弃
    lt4 := s.TakeWhile(func(i int) bool { return i < 4 })
    fmt.Println(lt4) // [1 2 3]
}

高级用法

链式调用

hasgo支持链式调用：

result := MySlice{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.
    Filter(func(i int) bool { return i%2 == 0 }). // 取偶数
    Map(func(i int) int { return i * i }).        // 平方
    Take(3).                                     // 取前3个
    Reverse()                                    // 反转
    
fmt.Println(result) // [36 16 4]

自定义类型操作

对于自定义结构体切片：

//go:generate hasgo -types=PersonSlice=Person
package main

type Person struct {
    Name string
    Age  int
}

type PersonSlice []Person

func main() {
    people := PersonSlice{
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 20},
    }
    
    // 获取年龄大于25岁的人名
    names := people.
        Filter(func(p Person) bool { return p.Age > 25 }).
        Map(func(p Person) string { return p.Name })
    
    fmt.Println(names) // ["Bob"]
}

性能考虑

hasgo生成的代码是类型安全的，没有反射开销，性能接近手写代码。但要注意：

1. 链式调用会创建中间切片，可能影响性能
2. 对于大数据集，考虑使用更底层的循环

总结

hasgo为Golang带来了Haskell风格的函数式编程体验，主要特点：

• 类型安全，无反射开销
• 支持链式调用
• 代码生成方式，性能良好
• 提供丰富的函数式操作

通过go generate可以轻松为自定义切片类型添加这些功能，是Golang中进行函数式编程的实用工具。