Often it is useful to execute one transformation after another to form a cascade of method calls on successive sequences obtained from consecutive transformations.

For example, suppose we want to compute the sum of the squares of a sequence of integers:

```scala> a
res: Array[Int] = Array(752, 884, 995, 462, 126, 632, 445)
```

This is easy – first map to obtain the squares and then reduce to obtain the sum of squares:

```scala> a.map(x => x*x).reduce(_ + _)
res: Int = 3163754
```

Or suppose we want to compute the sum of squares of all even integers.

No problem – first filter to get the even integers, then map to get the squares, and finally reduce to get the sum:

```scala> a.filter(_ % 2 == 0).map(x => x*x).reduce(_ + _)
res: Int = 1975704
```

The term cascading comes from the fact that for better readability such transformations are best written one after one another on separate lines (with comments!), so the transformations form a “cascade”:

```val result = a.filter(_ % 2 == 0)  // get even elements
.map(x => x*x)       // square
.reduce(_ + _)       // sum up
```

Note

Sometimes, copying multi-line examples into the Scala REPL causes problems because the console tries to execute each line independently. In such a situation you can wrap the multi-line expression in braces `{` `}` before giving it to the console. For example:

```scala> {
|       a.filter(_ % 2 == 0)  // get even elements
|        .map(x => x*x)       // square
|        .reduce(_ + _)       // sum up
|     }
res: Int = 1975704
```