Hi.

In the next two videos, we'll learn about higher order functions.

Higher order functions are functions that take other functions as parameters.

In the first video, we'll focus on using built In higher order functions.

Whereas in the second video, we'll create our own.

You may have noticed in earlier stages that in certain locations,

I used the foreach function to print elements in a collection.

Foreach is a high order function which takes another function as a parameter.

Let's take a look.

Let's recall our heroes array from an earlier lesson, when we called for

each on our heroes array, it would bring out every element in the array,

let's dive back into the code and take a look.

As we've noticed earlier,

we call the foreach function on the heros array then we pass in

the print line function and this in total prints out every element in our array.

Let's recompile our app and check out the results.

There are many other useful higher order functions in Scala, let's dive into them.

One of the ones I find myself using most is map.

Map allows us to apply a function to each element in a collection.

For example, if we have an array of elements, and we call them .mapfunction,

we iterate through the array and can perform actions on each element.

For instance, we created a function to convert each element in the array

to lowercase in order to achieve our result

we had to loop throughout the collection using a four loop.

However, now we can achieve the same result in a much more concise approach

using map.

Let's take a look.

In this line, we take the heroes array and call the map function on it to iterate

throughout all the elements of the collection and for

each one of these elements, we convert them to lower case.

Another way to write the above function literal is to use an underscore.

Think of an underscore as a wildcard which refers to the elements being iterated on.

Let's take a look at that.

Let's re-run our app and check out the results.

As expected, every element in the array, is lowercase, however,

this code is in a way more concise than what we had previously.

Another useful higher order function is filter.

Filter takes a function that returns a Boolean and builds a new collection in for

which the predicate is true.

In this case, we filter for

all the superheros that contain the string man in their name.

Let's take a look at the result.

Awesome.

As expected we got all the elements except for Thor.

Learning about higher order functions is great but

they become way more powerful if

we can learn how to use them together.

In this instance, we use the filter to grab only sent elements we want.

And then map to iterate to reach one nd return their value in upper case.

To dive in a little bit more detail, filter takes a function called contains

which checks if the string man exists, and then map takes a function

called two uppercase to convert the characters of the elements to uppercase.

Let's recompile our app and check out the results.

Awesome, as expected we filtered every element and

made sure that we only got back the ones containing the key word man.

And we're also able to change them to all upper case.

There are many other useful higher order functions such as count, drop while, drop

Index where which we can get familiar with by implementing an array of integeres.

Let's create an array of integers to get familiar with some of the higher order

functions we just mentioned.

Great, the first one we'll use is dropWhile, which loops

through the collection and drops any elements that do not satisfy a predicate.

In this case, any element less than three.

As expected, we drop any elements that were less than the value three,

hence number one and two are no longer in our array.

Another function, count, counts the number of elements that match the predicate.

In our case we'll check how many elements are less than or equal to four.

Let's recompile our app and check out our results.

Awesome.

As we can see, the numbers.count function returned seven elements and that's

because there's seven elements in the array that are less than or equal to four.

Another useful function is index ware.

Index ware returns the index of the element found or

a negative one if the element is not in the collection.

Let's take a look.

Awesome.

As expected, the value three is found in index two.

Remember, arrays are zero based even in scalar.

Great, we learned about higher order functions in Scala.

In the next video we'll create our own higher order function and

use it in our code.

See you here.