In this article I will explain what is higher order function and how to implement it in programming languages like c# and python.

# What is Higher Order Function(HOF):

so HOF is a function that either takes a function as an argument or returns a function. This type of function has implementations in many programming languages like javascript, python, Go, etc.

# Some examples:

let's build very simple function called `doOperation()`

which take a function as a first parameter and two numbers and will return a function that takes two numbers as an arguments,

we have also a function called `sum()`

that returns summation of two numbers.

### Python:

```
def doOperation(operation, num1, num2):
return operation(num1, num2)
def sum(number1, number2):
return number1 + number2
doOperation(sum, 2, 3)
-----------
Output: 5
-----------
```

### Csharp

```
public int DoSomthing(Func<int,int,int> sum, int num1,int num2) =>
sum(num1, num2);
public int sum(int number1, int number2) =>
number1 + number2;
DoSomthing(sum, 2, 3)
----------------
Output: 5
----------------
```

in cshap example we use a built in delegate `Func<int,int,int>`

which take 2 integer numbers and return integer to assign a `sum`

function to it.

So with this implementation we already apply higher order function.

## Another example

we want to create `filter()`

function to filter an array based on function we can pass it for this `filter()`

function.

### Python:

```
def filter(arr, action):
result= []
for num in arr:
if(action(num)):
result.append(num)
return result
def isOddNumber(num):
return num % 2 != 0
filter([1, 2, 3, 4, 5], isOddNumber)
----------------
Output: [1,3,5]
----------------
```

### Csharp

```
public static int[] Filter(int[] arr, Func<int, bool> func) =>
arr.Where(func).OrderBy(n => n).ToArray();
public static bool isOddNumber(int number) =>
number % 2 != 0;
Filter([1,2,3,4,5], isOddNumber)
------------------
Output: [1,3,5]
------------------
```

Hope it to be useful and thanks for reading!

## Discussion (1)

A brief overview of the performance of these implementations would be nice.