函数式编程-G中的一流函数

我来自具有一流功能支持的JavaScript。 例如,您可以:

  • 将一个函数作为参数传递给另一个函数
  • 从函数返回一个函数。

有人可以给我一个例子,说明我将如何在Go中执行此操作吗?

Drew LeSueur asked 2020-01-27T23:04:47Z
5个解决方案
41 votes

语言和函数式编程可能会有所帮助。 从此博客文章中:

package main
import fmt "fmt"
type Stringy func() string
func foo() string{
        return "Stringy function"
}
func takesAFunction(foo Stringy){
    fmt.Printf("takesAFunction: %v\n", foo())
}
func returnsAFunction()Stringy{
    return func()string{
        fmt.Printf("Inner stringy function\n");
        return "bar" // have to return a string to be stringy
    }
}
func main(){
    takesAFunction(foo);
    var f Stringy = returnsAFunction();
    f();
    var baz Stringy = func()string{
        return "anonymous stringy\n"
    };
    fmt.Printf(baz());
}

作者是博客所有者:Dethe Elza(不是我)

answered 2020-01-27T23:05:02Z
27 votes
package main

import (
    "fmt"
)

type Lx func(int) int

func cmb(f, g Lx) Lx {
    return func(x int) int {
        return g(f(x))
    }
}

func inc(x int) int {
    return x + 1
}

func sum(x int) int {
    result := 0

    for i := 0; i < x; i++ {
        result += i
    }

    return result
}

func main() {
    n := 666

    fmt.Println(cmb(inc, sum)(n))
    fmt.Println(n * (n + 1) / 2)
}

输出:

222111
222111
answered 2020-01-27T23:05:22Z
6 votes

规范的相关部分:函数类型。

这里的所有其他答案都首先声明一个新类型,这种类型很好(实践),并使您的代码更易于阅读,但知道这不是必需的。

您可以使用函数值,而无需为它们声明新的类型,如下面的示例所示。

声明一个函数类型的变量,该变量具有2个参数,类型为adder,并且具有一个返回值,类型为float64,如下所示:

// Create a var of the mentioned function type:
var f func(float64, float64) float64

让我们编写一个返回加法器函数的函数。 此加法器函数应采用2个类型为2171744889536054272的参数,并在调用时应返回这两个数字的和:

func CreateAdder() func(float64, float64) float64 {
    return func(x, y float64) float64 {
        return x + y
    }
}

让我们编写一个具有3个参数的函数,前2个是adder类型,第3个是函数值,该函数采用2个float64类型的输入参数并产生float64类型的值。 然后,我们正在编写的函数将调用传递给它的函数值作为参数,并使用前2个float64值作为函数值的参数,并返回传递的函数值返回的结果:

func Execute(a, b float64, op func(float64, float64) float64) float64 {
    return op(a, b)
}

让我们来看一下前面的示例:

var adder func(float64, float64) float64 = CreateAdder()
result := Execute(1.5, 2.5, adder)
fmt.Println(result) // Prints 4

请注意,创建adder时当然可以使用Short变量声明:

adder := CreateAdder() // adder is of type: func(float64, float64) float64

在Go Playground上尝试这些示例。

使用现有功能

当然,如果您已经在具有相同函数类型的包中声明了一个函数,则也可以使用该函数。

例如2具有相同的功能类型:

func Mod(x, y float64) float64

因此,您可以将此值传递给我们的2函数:

fmt.Println(Execute(12, 10, math.Mod)) // Prints 2

打印2,因为12 mod 10 = 2。请注意,现有功能的名称充当功能值。

在Go Playground上尝试一下。

注意:

请注意,参数名称不是该类型的一部分,具有相同参数和结果类型的2个函数的类型相同,而与参数名称无关。 但是要知道,在参数或结果的列表中,名称必须全部存在或不存在。

因此,例如,您还可以编写:

func CreateAdder() func(P float64, Q float64) float64 {
    return func(x, y float64) float64 {
        return x + y
    }
}

要么:

var adder func(x1, x2 float64) float64 = CreateAdder()
icza answered 2020-01-27T23:07:03Z
1 votes

虽然您可以使用var或声明类型,但是不需要。您可以非常简单地执行此操作:

package main

import "fmt"

var count int

func increment(i int) int {
    return i + 1
}

func decrement(i int) int {
    return i - 1
}

func execute(f func(int) int) int {
    return f(count)
}

func main() {
    count = 2
    count = execute(increment)
    fmt.Println(count)
    count = execute(decrement)
    fmt.Println(count)
}

//The output is:
3
2
Carl answered 2020-01-27T23:07:23Z
0 votes

只是具有递归函数定义的脑筋急转弯,用于在Web应用程序中链接中间件。

一,工具箱:

func MakeChain() (Chain, http.Handler) {
    nop := http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {})
    var list []Middleware
    var final http.Handler = nop
    var f Chain
    f = func(m Middleware) Chain {
        if m != nil {
            list = append(list, m)
        } else {
            for i := len(list) - 1; i >= 0; i-- {
                mid := list[i]

                if mid == nil {
                    continue
                }

                if next := mid(final); next != nil {
                    final = next
                } else {
                    final = nop
                }
            }

            if final == nil {
                final = nop
            }
            return nil
        }
        return f
    }
    return f, final
}

type (
    Middleware func(http.Handler) http.Handler
    Chain      func(Middleware) Chain
)

如您所见,类型Chain是一个函数,它返回相同类型Chain(这是第一类!)的另一个函数。

现在进行一些测试以查看其实际效果:

func TestDummy(t *testing.T) {
    c, final := MakeChain()
    c(mw1(`OK!`))(mw2(t, `OK!`))(nil)
    log.Println(final)

    w1 := httptest.NewRecorder()
    r1, err := http.NewRequest("GET", "/api/v1", nil)
    if err != nil {
        t.Fatal(err)
    }
    final.ServeHTTP(w1, r1)
}

func mw2(t *testing.T, expectedState string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            val := r.Context().Value(contextKey("state"))
            sval := fmt.Sprintf("%v", val)
            assert.Equal(t, sval, expectedState)
        })
    }
}

func mw1(initialState string) func(next http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx := context.WithValue(r.Context(), contextKey("state"), initialState)
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

type contextKey string

同样,这只是一个脑筋急转弯,表明我们可以以不同的方式在Go中使用一流的函数。 我个人现在使用chi作为路由器和用于处理中间件。

Kaveh Shahbazian answered 2020-01-27T23:08:01Z
translate from https://stackoverflow.com:/questions/4358031/first-class-functions-in-go