编辑“︁Go 柯里化”︁

= Go柯里化 =

'''柯里化'''（Currying）是函数式编程中的一种重要技术，它将接受多个参数的函数转换为一系列接受单个参数的函数。在Go语言中，虽然原生支持不如Haskell等纯函数式语言，但通过闭包和函数类型仍能实现柯里化。本章将详细介绍Go中的柯里化概念、实现方法及实际应用。

== 基本概念 ==

柯里化得名于逻辑学家Haskell Curry，其核心思想是：任何多参数函数都可以表示为单参数函数的链式调用。数学上表示为：

<math>
f(x, y) \Rightarrow curry(f) = x \mapsto (y \mapsto f(x, y))
</math>

在Go中，这意味着我们可以通过闭包逐步构建最终函数。例如，一个两参数加法函数<code>add(a, b)</code>可以柯里化为<code>addCurried(a)(b)</code>。

== 实现方法 ==

=== 基础柯里化示例 ===
以下展示如何将普通函数转换为柯里化形式：

<syntaxhighlight lang="go">
package main

import "fmt"

// 原始函数
func add(a int, b int) int {
    return a + b
}

// 柯里化版本
func addCurried(a int) func(int) int {
    return func(b int) int {
        return a + b
    }
}

func main() {
    // 原始调用
    fmt.Println(add(2, 3)) // 输出: 5

    // 柯里化调用
    addTwo := addCurried(2)
    fmt.Println(addTwo(3))  // 输出: 5
    fmt.Println(addCurried(2)(3)) // 输出: 5
}
</syntaxhighlight>

=== 多参数柯里化 ===
对于更多参数的情况，可以逐层嵌套：

<syntaxhighlight lang="go">
func multiplyThree(a, b, c int) int {
    return a * b * c
}

func curryMultiplyThree(a int) func(int) func(int) int {
    return func(b int) func(int) int {
        return func(c int) int {
            return a * b * c
        }
    }
}

// 使用示例
func main() {
    step1 := curryMultiplyThree(2)
    step2 := step1(3)
    result := step2(4) // 2*3*4 = 24
    fmt.Println(result)
}
</syntaxhighlight>

== 实际应用场景 ==

=== 配置预置 ===
柯里化适合需要预设部分参数的场景，例如HTTP中间件：

<syntaxhighlight lang="go">
func loggerMiddleware(serviceName string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            log.Printf("[%s] %s %s", serviceName, r.Method, r.URL.Path)
            next.ServeHTTP(w, r)
        })
    }
}

// 使用
adminLogger := loggerMiddleware("admin")
router.Use(adminLogger)
</syntaxhighlight>

=== 数学计算 ===
在数学运算中创建特定计算器：

<syntaxhighlight lang="go">
func taxCalculator(rate float64) func(float64) float64 {
    return func(amount float64) float64 {
        return amount * (1 + rate)
    }
}

// 创建特定税率计算器
vatCalculator := taxCalculator(0.2) // 20%增值税
fmt.Println(vatCalculator(100))    // 输出: 120
</syntaxhighlight>

== 进阶主题 ==

=== 自动柯里化工具 ===
可以通过反射实现自动柯里化（注意：反射会影响性能）：

<syntaxhighlight lang="go">
import "reflect"

func Curry(fn interface{}) interface{} {
    v := reflect.ValueOf(fn)
    if v.Kind() != reflect.Func {
        panic("Curry: 参数必须是函数")
    }

    return createCurriedFunc(v, []reflect.Value{})
}

// 辅助函数（实际实现更复杂）
func createCurriedFunc(fn reflect.Value, args []reflect.Value) interface{} {
    // 实现逻辑...
}
</syntaxhighlight>

=== 与泛型结合 ===
Go 1.18+的泛型可以增强柯里化的类型安全：

<syntaxhighlight lang="go">
func Curry[T1, T2, R any](f func(T1, T2) R) func(T1) func(T2) R {
    return func(t1 T1) func(T2) R {
        return func(t2 T2) R {
            return f(t1, t2)
        }
    }
}
</syntaxhighlight>

== 性能考量 ==

柯里化会带来额外的函数调用开销，在性能敏感场景应谨慎使用。以下是简单对比：

<mermaid>
barChart
    title 函数调用开销比较
    x-axis 调用方式
    y-axis 纳秒/操作
    bar 直接调用: 5
    bar 柯里化调用: 20
</mermaid>

== 总结 ==

* '''优点''':
  * 提高代码复用性
  * 实现延迟计算
  * 创建专用函数变体
* '''缺点''':
  * 增加调用栈深度
  * 可能降低代码可读性
  * Go中需要手动实现

柯里化是函数式编程的重要模式，虽然在Go中不是原生特性，但合理使用能显著提升代码表达能力。建议在需要部分应用或创建函数工厂时采用此技术。

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 函数式编程]]