GoLang Tutorial - Closures and Anonymous Functions

Regular function

The code below also has a regular function (with its name):

Anonymous function

Let's add an anonymous function (without any function name):

Returning an anonymous function

Now we want to add a regular function returning an anonymous function:

Let's look into the anonymous function more closely:

Note that the () means call and execute the anonymous function. If we write only func(){} without () in func(){}(), we only declare the anonymous function without calling it.

go supports anonymous functions which can form closures.

We can define a function inline without having to name it.

Go functions may be closures.

As we can see from the output, it printed 1, 2, and then 3, and so on. This means the int_seq() is keeping track of the values of i even though it's gone out of scope (outside its function body). That's the key point of a closure.

A closure is a function value (next_int()) that references variables (i) from outside its body (int_seq()). But still remembers the value. The function may access and assign to the referenced variables; in this sense the function is "bound" to the variables.

Let's create another separate instance of the function, int_seq(). In the following code, it's next_int2:

We see the two instances are independent of each other, they are separate instances!

Ref:
Closures - Go Lang Programming Tutorial: Part 15

As an another sample for the closures, in the following code, the fiboi() is a function that returns a function that returns an int:

The code: fibonacci-sequence.go

Note that to get the output value from the function we need to put the returned function into a loop.

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)