# More on Functions in Scala

In this article, we shall see about two concepts:

- Lambda Functions (Anonymous Functions)
- Higher-order Functions

As already mentioned, Scala supports both **object-oriented** and **functional** programming.
This article covers a bit of functional programming concepts.

## Lambda Functions

Lambda functions are functions that do not have a name. They are used to help keep code concise and readable.

You might already be using lambda functions without knowing about them.

`val items = Seq(1, 2, 3, 4);val even = items.filter(x => x % 2 == 0); // x => x % 2 == 0 is our lambda function.`

In the above example, we are passing a nameless function with one parameter
`x`

which checks whether `x % 2`

is 0 and returns true or false.

This nameless function is a lambda.

What is its use? Exactly what you see. They are used in places where you need to pass a function as a parameter.

By the way, functions that accept these lambas as parameters are higher-order functions.

## Higher-order Functions

These functions either accept other functions as parameters or return a function as a result.

Here's an example:

`def DoubleThis(fn: T => Boolean): Int`

Here, `T`

is a generic type inferred from the value of `p`

supplied.

Since this function accepts a function `p`

as a parameter, it is a HOF.

Example:

`def TrueOrFalse(n: Int): Boolean = { return if(n < 0) false else true;}def RunThisFunctionOnOne(fn: Int => Boolean) = { val result = fn(1); if(result == true) println("This is true"); else println("This is false");}RunThisFunctionOnOne(TrueOrFalse);`

In this example, we are passing the `TrueOrFalse`

function as a parameter
to `RunThisFunctionOnOne`

.

Let us see an example with a lambda.

`def RunThisFunctionOnOne(fn: Int => Boolean) = { val result = fn(1); if(result == true) println("This is true"); else println("This is false")}RunThisFunctionOnOne(n => if(n < 0) false else true);`

Common examples of HOFs you'd use commonly are methods like `filter`

, `find`

,
`map`

, `foreach`

, etc., that are found on collections.

### Function Types

Let us look into how function types are defined.

`val addTwoItems: (Int, Int) => Int = (a, b) => a + b;`

Here, `(Int, Int)`

is a list of parameter types.

`=> Int`

says that the function will return another
integer.

`= (a, b) => a + b`

is the actual lambda function.