#### Overview of this book

Scala Functional Programming Patterns
Credits
Aknowledgement
www.PacktPub.com
Preface
Free Chapter
Grokking the Functional Way
Singletons, Factories, and Builders
Recursion and Chasing your Own Tail
Lazy Sequences – Being Lazy, Being Good
Taming Multiple Inheritance with Traits
Of Visitors and Chains of Responsibilities
Traversals – Mapping/Filtering/Folding/Reducing
Higher Order Functions
Actors and Message Passing
Index

## Functions as first-class values

Let's run to the REPL and try out the following command:

```scala> val pred = (y: Int) => y < 10
pred: Int => Boolean = <function1>
```

The REPL here is saying that `pred` is a function (`<function1>`). Scala functions are first-class values. What does this term mean? We can send a first-class value as a parameter to another function, just like we send an integer, a list, or string.

For example, we can find the type of `pred` just like we can of `Int`:

```scala> val q = 9
q: Int = 9
scala> :t q
Int
scala> :t pred
Int => Boolean
```

We can send the function `pred` to a function combinator, as shown in this code snippet:

```scala> List(1,11,2,22,3,33) filter(pred)
res3: List[Int] = List(1, 2, 3)
```

We can send a function to another function and return a function from another function as follows:

```scala> val pred1 = (y: Int) => y < 11 // 1
pred1: Int => Boolean = <function1>

scala> val higher: (Int => Boolean) => (Int...```