# Java: Nesting Functions with Stream Reduce

One of the less known stream operators is *Reduce*. I've studyied Haskell during University and *reduce* strongly reminds of Haskell's function *fold*.

#
What is *reduce* ?

*Given a list of elements and a function (aka accumulator), get a single resulting value.*

The easy example: make the sum of a list of Integers.

`Integer result = Stream.of(1, 2, 3, 4, 5).reduce(0, (a, b) -> a + b);`

That will make:

**1+2+3+4+5+0**

However, Streams api already solves that:

`Integer result = IntStream.of(1, 2, 3, 4, 5).sum();`

# Composite functions with Reduce

Suppose we have a list of functions and we want to build a function which contains all the ones from the list. Let see:

First we have:

`List<Function> functions = [f1,f2,f3,f4,f5]`

And we want a function like this:

`Function resultFunction = (X) -> f5( f4( f3 ( f2( f1(X) ) ) )`

## How can we easily build a composite function ?

First, we'll use *Function::andThen* method to wrap each function in another.

Then, we call *reduce* and the first argument is the *starting value*, as we are composing functions we use the **idempotent** element which, in this case, is the Identity Function.

```
List<Function> functions = [f1,f2,f3,f4,f5];
Function compositeFunction = functions.stream().reduce(a -> a, Function::andThen)
```

**What if we want to composite in the reverse order of the list ?**

Remember the array is:

`List<Function> functions = [f1,f2,f3,f4,f5]`

And now we need a function like this:

`Function resultFunction = (X) -> f1( f2( f3 ( f4( f5(X) ) ) )`

We have to change the *accumulator* to Function::compose

```
List<Function> functions = [f1,f2,f3,f4,f5];
Function compositeFunction = functions.stream().reduce(a -> a, Function::compose)
```

Altogether *Reduce* , *Function::compose* and *Function::andThen* conceive a powerfull tool to compose functions which is of great use.

## Discussion (0)