Does Go support lambda expressions or anything similar?
I want to port a library from another language that uses lambda expressions (Ruby).
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 !!
func() string {
return "some String Value"
}
//Js similar: () => 'some String Value'
func(arg string) string {
return "some String" + arg
}
//Js similar: (arg) => "some String Value" + arg
func() {
fmt.Println("Some String Value")
}
//Js similar: () => {console.log("Some String Value")}
func(arg string) {
fmt.Println("Some String " + arg)
}
//Js: (arg) => {console.log("Some String Value" + arg)}
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
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.
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.
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()); }
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/