New first-class functions concept exercise (#2103)

Author: antklim

concepts/first-class-functions/.meta/config.json

@@ -0,0 +1,5 @@
+{
+  "authors": ["antklim"],
+  "contributors": ["andrerfcsantos"],
+  "blurb": "Functions in Go can be used as regular values of the language."
+}

concepts/first-class-functions/about.md

@@ -0,0 +1,103 @@
+# About
+
+In Go, functions are first-class values. This means that you can do with functions the same things you can do with all other values - assign functions to variables, pass them as arguments to other functions or even return functions from other functions. 
+
+Below we are creating two functions, `engGreeting` and `espGreeting` and we are assigning them to the variable `greeting`:
+
+```go
+import "fmt"
+
+func engGreeting(name string) string {
+	return fmt.Sprintf("Hello %s, nice to meet you!", name)
+}
+
+func espGreeting(name string) string {
+	return fmt.Sprintf("¡Hola %s, mucho gusto!", name)
+}
+
+greeting := engGreeting			// greeting is a variable of type func(string) string
+fmt.Println(greeting("Alice"))	// Hello Alice, nice to meet you!
+
+greeting = espGreeting
+fmt.Println(greeting("Alice")) 	// ¡Hola Alice, mucho gusto!
+```
+
+Function values provide an opportunity to parametrize functions not only with data but with behavior too.
+In the following example, we are passing behaviour to the `dialog` function via the `greetingFunc` parameter:
+
+```go
+func dialog(name string, greetingFunc func(string) string) {
+	fmt.Println(greetingFunc(name))
+	fmt.Println("I'm a dialog bot.")
+}
+
+func espGreeting(name string) string {
+	return fmt.Sprintf("¡Hola %s, mucho gusto!", name)
+}
+
+greeting := engGreeting
+dialog("Alice", greeting)
+// Output:
+// ¡Hola Alice, mucho gusto!
+// I'm a dialog bot.
+```
+
+The value of an uninitialized variable of function type is `nil`.
+Therefore, calling a `nil` function value causes a panic.
+
+```go
+var dutchGreeting func(string) string
+dutchGreeting("Alice") // panic: call of nil function
+```
+
+Function values can be compared with `nil`. This can be useful to avoid unnecessary program panics.
+
+```go
+var dutchGreeting func(string) string
+if dutchGreeting != nil {
+	dutchGreeting("Alice") // safe to call dutchGreeting
+}
+```
+
+## Function types
+
+Using function values is possible thanks to the function types in Go. A function type denotes the set of all functions with the same sequence of parameter types and the same sequence of result types. User-defined types can be declared on top of function types. For instance, the `dialog` function from the previous examples can be updated as following:
+
+```go
+type greetingFunc func(string) string
+
+func dialog(name string, f greetingFunc) {
+	fmt.Println(f(name))
+	fmt.Println("I'm a dialog bot.")
+}
+```
+
+## Anonymous functions
+
+Another powerful tool that is available thanks to first-class functions support is anonymous functions. Anonymous functions are defined at their point of use, without a name following the `func` keyword. Such functions have access to the variables of the enclosing function.
+
+For example:
+
+```go
+func fib() func() int {
+	var n1, n2 int
+
+	return func() int {
+		if n1 == 0 && n2 == 0 {
+			n1 = 1
+		} else {
+			n1, n2 = n2, n1 + n2
+		}
+		return n2
+	}
+}
+
+next := fib()
+for i := 0; i < N; i++ {
+  fmt.Printf("F%d\t= %4d\n", i, next())
+}
+```
+
+A call to `fib` initializes the variables `n1` and `n2` and returns an anonymous function that, in turn, changes the values of these variables each time the function is called. Nth calls of the anonymous function return the Nth number of the Fibonacci sequence starting from 0. The anonymous inner function has access to the local variables (`n1` and `n2`) of the enclosing function `fib`. This is a great way to have function values keep state between calls. We say that the anonymous function is a closure of the variables `n1` and `n2`. [Closures][closure] are widely used in programming and you might see other languages supporting them.
+
+[closure]: https://en.wikipedia.org/wiki/Closure_(computer_programming)

concepts/first-class-functions/introduction.md

@@ -0,0 +1,103 @@
+# Introduction
+
+In Go, functions are first-class values. This means that you can do with functions the same things you can do with all other values - assign functions to variables, pass them as arguments to other functions or even return functions from other functions. 
+
+Below we are creating two functions, `engGreeting` and `espGreeting` and we are assigning them to the variable `greeting`:
+
+```go
+import "fmt"
+
+func engGreeting(name string) string {
+	return fmt.Sprintf("Hello %s, nice to meet you!", name)
+}
+
+func espGreeting(name string) string {
+	return fmt.Sprintf("¡Hola %s, mucho gusto!", name)
+}
+
+greeting := engGreeting			// greeting is a variable of type func(string) string
+fmt.Println(greeting("Alice"))	// Hello Alice, nice to meet you!
+
+greeting = espGreeting
+fmt.Println(greeting("Alice")) 	// ¡Hola Alice, mucho gusto!
+```
+
+Function values provide an opportunity to parametrize functions not only with data but with behavior too.
+In the following example, we are passing behaviour to the `dialog` function via the `greetingFunc` parameter:
+
+```go
+func dialog(name string, greetingFunc func(string) string) {
+	fmt.Println(greetingFunc(name))
+	fmt.Println("I'm a dialog bot.")
+}
+
+func espGreeting(name string) string {
+	return fmt.Sprintf("¡Hola %s, mucho gusto!", name)
+}
+
+greeting := engGreeting
+dialog("Alice", greeting)
+// Output:
+// ¡Hola Alice, mucho gusto!
+// I'm a dialog bot.
+```
+
+The value of an uninitialized variable of function type is `nil`.
+Therefore, calling a `nil` function value causes a panic.
+
+```go
+var dutchGreeting func(string) string
+dutchGreeting("Alice") // panic: call of nil function
+```
+
+Function values can be compared with `nil`. This can be useful to avoid unnecessary program panics.
+
+```go
+var dutchGreeting func(string) string
+if dutchGreeting != nil {
+	dutchGreeting("Alice") // safe to call dutchGreeting
+}
+```
+
+## Function types
+
+Using function values is possible thanks to the function types in Go. A function type denotes the set of all functions with the same sequence of parameter types and the same sequence of result types. User-defined types can be declared on top of function types. For instance, the `dialog` function from the previous examples can be updated as following:
+
+```go
+type greetingFunc func(string) string
+
+func dialog(name string, f greetingFunc) {
+	fmt.Println(f(name))
+	fmt.Println("I'm a dialog bot.")
+}
+```
+
+## Anonymous functions
+
+Another powerful tool that is available thanks to first-class functions support is anonymous functions. Anonymous functions are defined at their point of use, without a name following the `func` keyword. Such functions have access to the variables of the enclosing function.
+
+For example:
+
+```go
+func fib() func() int {
+	var n1, n2 int
+
+	return func() int {
+		if n1 == 0 && n2 == 0 {
+			n1 = 1
+		} else {
+			n1, n2 = n2, n1 + n2
+		}
+		return n2
+	}
+}
+
+next := fib()
+for i := 0; i < N; i++ {
+  fmt.Printf("F%d\t= %4d\n", i, next())
+}
+```
+
+A call to `fib` initializes the variables `n1` and `n2` and returns an anonymous function that, in turn, changes the values of these variables each time the function is called. Nth calls of the anonymous function return the Nth number of the Fibonacci sequence starting from 0. The anonymous inner function has access to the local variables (`n1` and `n2`) of the enclosing function `fib`. This is a great way to have function values keep state between calls. We say that the anonymous function is a closure of the variables `n1` and `n2`. [Closures][closure] are widely used in programming and you might see other languages supporting them.
+
+[closure]: https://en.wikipedia.org/wiki/Closure_(computer_programming)

concepts/first-class-functions/links.json

@@ -0,0 +1,14 @@
+[
+  {
+    "url": "https://go.dev/ref/spec#Function_types",
+    "description": "Go Language Spec: Function types"
+  },
+  {
+    "url": "https://go.dev/tour/moretypes/24",
+    "description": "Tour of Go: Function values"
+  },
+  {
+    "url": "https://golangbot.com/first-class-functions/",
+    "description": "Golang tutorial: First Class Functions"
+  }
+]

config.json

@@ -387,6 +387,21 @@
         ],
         "status": "beta"
       },
+      {
+        "slug": "expenses",
+        "name": "Expenses",
+        "uuid": "7221b17b-7880-4228-a07a-121e5857c953",
+        "concepts": [
+          "first-class-functions"
+        ],
+        "prerequisites": [
+          "for-loops",
+          "functions",
+          "structs",
+          "type-definitions"
+        ],
+        "status": "beta"
+      },
       {
         "slug": "animal-magic",
         "name": "Animal Magic",
@@ -1957,6 +1972,11 @@
       "slug": "functions",
       "uuid": "e737f47b-5d1a-423a-8d6a-cd201a6e4e44"
     },
+    {
+      "name": "First class functions",
+      "slug": "first-class-functions",
+      "uuid": "66968174-701b-484c-a84d-f919b4756022"
+    },
     {
       "name": "Floating-point numbers",
       "slug": "floating-point-numbers",

exercises/concept/expenses/.docs/hints.md

@@ -0,0 +1,31 @@
+# Hints
+
+## 1. Implement a general records filter
+
+- Create a new `[]Record` to hold the filtered results
+- Iterate over the records and call the predicate function on each one
+- Add to the results slice only the records for which calling the predicate function on them returns `true`
+
+## 2. Filter records within a period of time
+
+- Make the function return an anonymous function that receives a `Record` and returns a `bool` indicating if the record is within the period of time that `ByDaysPeriod` receives as an argument.
+- Inside your anonymous function, you have access to the `DaysPeriod` argument that `ByDaysPeriod` receives. Together with the `Record` argument of the anonymous function, make a boolean expression that checks if the day in the record is inside the `DaysPeriod` that `ByDaysPeriod` receives. Return that boolean expression from the anonymous function.
+
+## 3. Filter records by category
+
+- This is very similar to the previous task, but now you are dealing with a category instead of a period of time.
+- Make the function return an anonymous function that receives a `Record` and returns a `bool` indicating if the record belongs to the category that `ByCategory` receives as an argument.
+- Inside your anonymous function, you have access to the category argument that `ByCategory` receives. Together with the `Record` argument of the anonymous function, make a boolean expression that checks if the category of the record is the same as the category that `ByCategory` receives as an argument. Return that boolean expression from the anonymous function.
+
+## 4. Calculate the total amount of expenses in a period
+
+- Use the `ByDaysPeriod` function you made in step 2 to make a period filter function.
+- Pass that filter function as the second argument of the `Filter` function you made in step 1. This allows you to filter the results by a period of time.
+- Iterate over the filtered records and sum up all their amounts.
+
+## 5. Calculate the total expenses for records of a category in a period
+
+- Use the `ByCategory` function you made in step 3 to make a category filter function.
+- Pass that filter function as the second argument of the `Filter` function you made in step 1. This allows you to filter the results by a particular category.
+- After filtering the records by category, check if you have any records for thatcategory. If you don't, you must return an error.
+- If you have records belonging to that category, compute the total expenses for the given period of time using the `TotalByPeriod` function you made in step 4.