Does Go have lambda expressions or anything similar?

Question

Does Go support lambda expressions or anything similar?

I want to port a library from another language that uses lambda expressions (Ruby).

Answer 1

Yes.

Here is an example, copied and pasted carefully:

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());
}

Answer 2

Lambda expressions are also called function literals. Go supports them completely.

See the language spec: http://golang.org/ref/spec#Function_literals

See a code-walk, with examples and a description: http://golang.org/doc/codewalk/functions/

Answer 3

Yes

In computer programming, an anonymous function or lambda abstraction (function literal) is a function definition that is not bound to an identifier, and Go supports anonymous functions, which can form closures. Anonymous functions are useful when you want to define a function inline without having to name it.

    package main
    import "fmt"

    func intSeq() func() int {
        i := 0
        return func() int {
            i += 1
            return i
        }
    }


    func main() {
       nextInt := intSeq()
       fmt.Println(nextInt())
       fmt.Println(nextInt())
       fmt.Println(nextInt())
       newInts := intSeq()
       fmt.Println(newInts())
    }

function intSeq returns another function, which we define anonymously in the body of intSeq. The returned function closes over the variable i to form a closure.

Output
$ go run closures.go
1
2
3
1

Answer 4

The golang does not seem to make lambda expressions, but you can use a literal anonymous function, I wrote some examples when I was studying comparing the equivalent in JS, I hope it helps !!

no args return string:

func() string {
    return "some String Value"
}
//Js similar: () => 'some String Value'

with string args and return string

func(arg string) string {
    return "some String" + arg
}
//Js similar: (arg) => "some String Value" + arg

no arguments and no returns (void)

func() {
   fmt.Println("Some String Value")
} 
//Js similar: () => {console.log("Some String Value")}

with Arguments and no returns (void)

func(arg string) {
    fmt.Println("Some String " + arg)
}
//Js: (arg) => {console.log("Some String Value" + arg)}

Answer 5

An example that hasn't been provided yet that I was looking for is to assign values directly to variable/s from an anonymous function e.g.

test1, test2 := func() (string, string) {
    x := []string{"hello", "world"}
    return x[0], x[1]
}()

Note: you require brackets () at the end of the function to execute it and return the values otherwise only the function is returned and produces an assignment mismatch: 2 variable but 1 values error.

Answer 6

Here is a 'curried function' example. However the syntax seems unclear, relative to the lambda function syntax in other languages such as Swift, C#, etc.

func main() int { 
  var f func(string) func(string) int
  f = func(_x1 string) func(string) int { return func(_x2 string) int { return strings.Compare(_x1,_x2) } }
  return ((f)("b"))("a")
}

Answer 7

Yes, since it is a fully functional language, but has no fat arrow (=>) or thin arrow (->) as the usual lambda sign, and uses the func keyword for the sake of clarity and simplicity.