go-lang是怎么做的？

Question

在像Haskell这样的函数式编程中，我可以定义函数

add a b = a+b

然后，add 3将返回一个接受一个参数的函数，并将返回3 + something

我如何在GO中做到这一点？

当我定义一个带有多个(例如n个)参数的函数时，我是否可以只给它一个参数，并获得另一个接受n-1个参数的函数？

更新

很抱歉，我的原始问题中的措辞不准确。

我认为我的问题应该被问成两个问题：

• GO中有没有部分应用程序？
• GO如何做函数curry?

感谢TheOnly92和Alex解决了我的第二个问题。然而，我也对第一个问题感到好奇。

Answer 1

在上一个答案的基础上进行扩展，它允许您接受任意数量的参数：

package main

import (
    "fmt"
)

func mkAdd(a int) func(...int) int {
    return func(b... int) int {
        for _, i := range b {
            a += i
        }
        return a
    }
}

func main() {
    add2 := mkAdd(2)
    add3 := mkAdd(3)
    fmt.Println(add2(5,3), add3(6))
}

Answer 2

也许是像这样的

package main

import (
    "fmt"
)

func mkAdd(a int) func(int) int {
    return func(b int) int {
        return a + b
    }
}

func main() {
    add2 := mkAdd(2)
    add3 := mkAdd(3)
    fmt.Println(add2(5), add3(6))
}

Answer 3

您可以更进一步，通过定义函数类型，然后向其添加方法。

package main

import "fmt"

type Add func(int, int) int

func (f Add) Apply(i int) func(int) int {
    return func(j int) int {
        return f(i, j)
    }
}

func main() {
    var add Add = func(i, j int) int { return i + j }
    add3 := add.Apply(3)
    fmt.Println("add 3 to 2:", add3(2))
}

您甚至可以尝试使用可变函数：

package main

import "fmt"

type Multiply func(...int) int

func (f Multiply) Apply(i int) func(...int) int {
    return func(values ...int) int {
        values = append([]int{i}, values...)
        return f(values...)
    }
}

func main() {
    var multiply Multiply = func(values ...int) int {
        var total int = 1
        for _, value := range values {
            total *= value
        }
        return total
    }


    var times2 Multiply = multiply.Apply(2)
    fmt.Println("times 2:", times2(3, 4), "(expect 24)")

    // ... and you can even cascade (if assigned the Multiply type)
    times6 := times2.Apply(3)
    fmt.Println("times 6:", times6(2, 3, 5, 10), "(expect 1800)")
}

希望这能有所帮助！