Explain the use of Go's function composition and function chaining for creating and using composed and chained functions in Go programs?
The use of Go's function composition and function chaining are as follows:
Function composition in Go involves creating a new function that is the composition of two or more existing functions. The resulting function takes an argument, passes it through the chain of functions, and returns the final result. Here is an example of function composition:
func addOne(x int) int {
return x + 1
}
func multiplyByTwo(x int) int {
return x * 2
}
func main() {
// compose addOne and multiplyByTwo
compose := func(f, g func(int) int) func(int) int {
return func(x int) int {
return g(f(x))
}
}
// create a new function that adds one and then multiplies by two
f := compose(addOne, multiplyByTwo)
// use the new function
result := f(2)
fmt.Println(result) // output: 6
}
Function chaining in Go involves chaining together multiple method calls on an object, where each method call returns the object itself, allowing for method chaining. Here is an example of function chaining:
type Person struct {
name string
age int
}
func (p *Person) SetName(name string) *Person {
p.name = name
return p
}
func (p *Person) SetAge(age int) *Person {
p.age = age
return p
}
func main() {
// create a new person and chain method calls
person := &Person{}
person.SetName("John").SetAge(30)
// use the person object
fmt.Printf("%s is %d years old.", person.name, person.age) // output: John is 30 years old.
}
In this example, the **SetName**
and **SetAge**
methods return a pointer to the **Person**
object, which allows for method chaining.