# How To Pass A Function As An Argument Using A Higher-Order Function In Go?

ยท

In Go, functions are first-class citizens, which means they can be treated like any other value. This includes passing functions as arguments to other functions, which is a powerful technique that enables you to write more flexible and reusable code. In this article, we'll explore how to pass a function as an argument using a higher-order function in Go, with examples to illustrate the concepts.

### Higher-Order Functions:

A higher-order function is a function that takes one or more functions as arguments, or returns a function as its result. In Go, higher-order functions are a powerful tool that can be used to create more flexible and reusable code. Here's an example of a higher-order function in Go:

``````func apply(f func(int) int, x int) int {
return f(x)
}
``````

In the above example, `apply` is a higher-order function that takes a function `f` that takes an integer and returns an integer, and an integer `x`. The function `apply` applies the function `f` to the integer `x`, and returns the result.

### Passing a Function as an Argument:

To pass a function as an argument using a higher-order function in Go, you simply specify the function as an argument to the higher-order function. Here's an example:

``````func double(x int) int {
return x * 2
}

func apply(f func(int) int, x int) int {
return f(x)
}

func main() {
result := apply(double, 5)
fmt.Println(result) // 10
}
``````

In the above example, we define a function `double` that takes an integer `x` and returns `x * 2`. We then define the `apply` function as before. In the `main` function, we call the `apply` function with the `double` function and the integer `5` as arguments. The `apply` function applies the `double` function to the integer `5`, and returns the result `10`.

### Passing a Custom Function as an Argument:

You can also pass a custom function as an argument using a higher-order function in Go. Here's an example:

``````func addOne(x int) int {
return x + 1
}

func apply(f func(int) int, x int) int {
return f(x)
}

func main() {
fmt.Println(result) // 6
}
``````

In the above example, we define a function `addOne` that takes an integer `x` and returns `x + 1`. We then define the `apply` function as before. In the `main` function, we call the `apply` function with the `addOne` function and the integer `5` as arguments. The `apply` function applies the `addOne` function to the integer `5`, and returns the result `6`.

### Conclusion:

Passing a function as an argument using a higher-order function in Go is a powerful technique that enables you to write more flexible and reusable code. By understanding the concept of higher-order functions, and how to pass functions as arguments using a higher-order function, you can take full advantage of the power and flexibility of Go's first-class functions. Whether you're writing complex algorithms or simple utility functions, the ability to pass functions as arguments is a valuable tool to have in your programming arsenal.