To get the section sorted data into our tableView,

we need to rewrite the implementations to the data source methods and

add a few more protocol methods to give the tableView some of this extra detail.

Before we do any of that though, we need to switch out our data source.

We're no longer using just the basic context array.

Because we want the section context.

So I'll say var sections = ContactsSource.sectionedContacts.

We get a couple errors here and there when we do this, but they're easy to sort out.

So the first data source method number of sections is now invalid,

because we don't have a single section anymore.

Let's replace this one with sections.count.

Now we'll have an appropriate number of sections for the tableView to display.

Okay? What about rows?

The implementation for the number of rows in section is also incorrect.

Remember that tableView is setting itself up and calls this method,

it always provides an argument for which section it's currently in.

When we first provided an implementation for this method

we ignored the section argument because we just had the one long list.

We can now use that argument to retrieve the nested array for

the correct section and return the number of values.

So we'll say return sections, and this is an array of arrays.

So we want to first get a nested array,

and we'll do that by using the section argument.

And now we want to call count on that inner array

to return the number of rows for each section.

We have two more errors here and

that's because we're now trying to retrieve a single contact

from a nested array, so basically from the outside right we need to fix it.

The fix here is simple though we first need to get that nested array

out using the section value from the index path argument.

Now earlier we discarded that and it's easy, so let contact equals, so

we'll get rid of all of this.

We'll say sections and first we want to get the right inner array,

we'll say indexPath.section and then, from that inner array,

we want to get the right rows so, indexPath.row.

If you're confused as to what's going on here,

all I'm doing is chaining subscript calls indexPath.section,

as an index value, is going to get me the appropriate nested array.

And then from there, I'll use indexPath.row, just like before,

to match up the row to the array value.

And we need to do the same thing below, to get rid of that error.

So we can just copy and paste.

If we run the app now, so everything is sorted properly, which is awesome.

But our contacts aren't sectioned off.

And that's because while the tableView now knows about our sections and

how to section off our data,

we haven't given any information about how to title and display the section.

So let's add one more data source method, and I'll do it at the top.

This method is an optional method in the protocol because as we saw

earlier we won't always have section data.

This method is called tableView titleForHeaderInSection.

And returns a string to use as a title for a given section.

Before we provide an implementation let's add here as a stored property,

the array of unique first letters to use as titles.

So I'll say, let sectionTitles = ContactsSource.sortedUniqueFirstLetters.

Now, back in the method, we can return the right string to use as a title for

the relevant section pretty simply by saying return sectionTitles[section].

Right, so this is the section argument passed in when the tableView

calls this method, and we use that to get the correct letter, run the app again,

now we need to include the override keyword here,

now if we run it, we still have an error, okay no more.

Xcode is just now catching up with me Hey, look at that pretty awesome, right?

So it says A, all the contacts with the letter A,

and goes that way all the way down.

We can do one more cool thing though,

you know how in the contact sample on the right-hand side there's this

index of sections titles that you can tap to quickly go to section?

Let's add that as well.

Now the Data Source method we need to provide for

an implementation here, is sectionIndexTitles for tableView.

We'll do that at the top.

So we'll say sectionIndexTitles for tableView and

we need to return an array of section titles.

That's easy, we've already done this work.

So, we'll go ahead and return the section titles array.

And now if we run the app as always, I forgot my override keyword.

If you run the app now, look at that.

We've built ourselves a decent contacts app.

You can actually click here to quickly go to the letter.