One of the most common operations we conduct with arrays

is to iterate through it and

use elements that match a particular predicate or set of requirements.

For example, you've written code in the past to iterate through a range of values

using a for loop and append to a new array only the even numbered values.

Of course, there's another standard library function to handle

exactly this kind of code, the filter function.

So, new comment, filter.

As an example of how filter works, let's try and

get an array of even numbers from 1 to 100.

So I can say, let evenNumbers.

=, and here I'm going to create a range that goes from 1 to 100,

and then I'm going to call filter on it,

and sort out just the even numbers.

Super easy, just a single line of code.

And if I do print(evenNumbers),

you should see a bunch of even numbers in your console.

Of course, as we've been doing so far, the easiest way to understand what filter does

is to build a simple version ourselves.

And again, as with previous examples, we'll start with an extension on array.

Unlike map or a flat map, filter doesn't define its own

generic parameter because it always has a specific signature.

So, I'll call this customFilter.

Filter takes a closure as an argument with a type signature of element to bool.

Remember that element refers to the arrays type parameter.

Basically, the closure takes a generic parameter, performs some logic on

it to determine whether it fits our criteria, and then returns true or false.

If we return true from our logical check,

then we include the element in a new array, otherwise we don't.

Since we're simply filtering through an array and not transforming it,

the return type of filter is the same type as the existing array.

So, here will say, isIncluded, which is our function that checks to see if

we want to include this element in a new array.

And the signature is Element to Bool.

And again, because we're not transforming the return type is going to be an array of

the same type, so an array of Element.

These types of functions always return a new array because we want to maintain

immutability of data.

So, we always create a new array.

Like before, we'll start off with a result,

which is a new array that we're going to append our elements to.

And we'll create an empty array to start out.

Again, we're going to iterate through self and grab each element, but

this time we're going to do something special.

Here we're going to use a where clause.

A where clause, just like with generic code, is used to introduce a constraint.

Now, here though, it's a lot more flexible, and essentially,

you can provide any expression that returns a Boolean value as a condition,

much like any control flow statement.

So, after this where, we can include a predicate.

Which is some logic that matches an element to a set of criteria and

returns either true or false.

If true, then we enter the body of the for

loop, otherwise we just jump to the next iteration.

So, here I'm going to say for x in self where isIncluded(x).

What this does is it means we only enter the for

loop if the result of calling isIncluded on x is true.

So, isIncluded is the closure passed into the filter function.

And if we call that closure using the current value of x from the array,

if that's true, we step in, otherwise we just move to the next iteration.

So, in that case if it's true, we'll just say result.append(x).

Make sure you don't take result.append(contentsOf).

After that, all we're going to do is return results.

Because filter always has to return a Boolean value, the closure expression

we pass in must perform a comparison operation and return a Boolean.

So, let's look at another variation of using the accounts example.

Let's say in our app we displayed a central directory of all accounts,

much like your contacts app.

Just like in your contacts app, let's say there was a search bar up at the top that

lets you type and filter through the list.

This is as simple as using the filter function.

For example, to get all the users whose user name start with P,

we can say let some PUsers = allusers.customfilter.

And we'll pass in a closer that says {

$0.username.characters.first == "p"}.

And it should do that and if you do print(somePUsers),

we'll see that there are only two accounts that have user names with P.

Our closure expression performs an equality operation

to check whether the first character in the username string is equal to P.

This returns true if it is or false otherwise and the filter function uses

that value to determine whether it should be appended to the new array or not.

Filter is a bit more intuitive to understand than map or flat map.

But works much in the same way, in that it is a very general purpose function

that takes any kind of closure expression matching the signature required.

This allows you to filter through nearly everything.

Okay, we have map, flat map, and filter done.

Next, let's walk through the reduce function.