Why won't my forEach lambda allow me to exit my function with a return statement in Java?
Tags: java, lambda, functional
Published: 2024-01-25 10:59:50

Let’s say you have a basket of food:

```
List<Food> basket = List.of(
     new Food("Apple", FRUIT),
     new Food("Banana", FRUIT),
     new Food("Carrot", VEGETABLE),
     new Food("Orange", FRUIT),
);
```

And a requirement to only accept this basket if it is only filled with fruits. To meet this requirement, you decide to implement a for loop:

```
private boolean containtsOnlyFruits(List<Food> basket) {
    for (Food food : basket) {
        if (food.getFoodType() != FRUIT) {
           return false;
        }
    }
    return true;
}
```

Then, you remember you’ve been learning about Java Lambdas and a more functional approach, so you decide to write the same thing in a forEach lambda:

```
private boolean containtsOnlyFruits(List<Food> basket) {
    basket.forEach(food -> {
        if (food.getFoodType() != FRUIT) {
            return false;
        }
    });
    return true;
}
```

Just to come across an error: 
`unexpected return value`

Why is that? 

A lambda is nothing more than a function. In this case, an anonymous function, or in other words, a function without a name. Just like any other function, a lambda can receive arguments and also expect something to be returned. 

When you try to return false from the forEach lambda, you’re actually trying to exit this anonymous function and output a boolean. However, the forEach function is not expected to return any result. This is simply not how this function is implemented. 

In fact, if you look at the implementation of the forEach function, you will see that it accepts a Consumer: 

```
default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}
```

A `Consumer` is an interface that represents an operation that accepts a single input argument and returns no result. In this implementation, you can see that under the hood, the forEach function is using a for each loop, performing the given action and not returning anything. 

So to satisfy our operation in a functional approach, we will need to find another lambda. There is a good candidates here: `allMatch`.

With the `allMatch` lambda, we can check if all of the elements of the basket is a fruit:

```
private boolean onlyFruits(List<Food> basket) {
    return basket.stream().allMatch(food -> food.getFoodType() == FRUIT);
}
```

If that’s the case, our lambda will return true. And if we look at the internal of `allMatch`:

```
boolean allMatch(Predicate<? super T> predicate);
```

We will see that the allMatch function expects a Predicate.

A `Predicate` is a functional interface just like a `Consumer`, but it works a bit differently. While a `Consumer` represents an operation that accepts a single input argument and returns no result, a `Predicate` represents a predicate (boolean-valued function) of one argument that is used to test an object for a condition and return a boolean value (true or false).

There are other very important functional interfaces. Can you tell me what they are and how they work? 

Stay curious! 

### Contribute
Writing takes time and effort. I love writing and sharing knowledge, but I also have bills to pay.

If you like my work, please consider donating through Buy Me a Coffee: https://www.buymeacoffee.com/RaphaelDeLio

Or by sending me BitCoin: 1HjG7pmghg3Z8RATH4aiUWr156BGafJ6Zw