[MUSIC]

Before we move on to the next set of features and logic,

let's take a second to review our code.

When we first learned about building apps, I talked about refactoring.

Refactoring is the process of changing the structure of our code,

without changing any functionality.

We've got a bit of our functionality going in the app, but

already I think our view controller is becoming a bit unwieldy.

This is a good time to maybe improve our code.

I should note, that over the next few videos, we're going to be using

some concepts that you haven't fully learned yet but will soon.

So take this as a series of bonus videos.

It's up to you if you want to implement these changes, but

I highly encourage you to just watch along anyway.

Let's review our potential set of problem areas.

The first thing I don't like is the fact that the code that sets up our different

views is all over the place inside the view controller.

And I'm talking about the PageController at the moment.

We've declared the labels and

the buttons, up at the top over here, as stored properties.

Then there's some setup code related to these image views, buttons, labels, and so

on, inside viewDidLoad as you can see here.

And then finally, there's some more in viewWillLayoutSubviews.

In fact, viewDidLoad does a lot of different things and

its responsibilities aren't entirely clear or straightforward.

One of these responsibilities, as you can see here,

is creating an attributed string with a certain set of styles.

This doesn't really need to be in viewDidLoad.

Maybe we can put this elsewhere.

We're also setting up buttons with choices.

Perhaps we can get all of this out of viewDidLoad as well.

So how do we proceed here?

Recently, we learned about lazy stored properties,

which are stored properties that aren't created until the need arises.

There's an interesting thing we can do with lazy stored properties that

can help us clean up our code.

Now you haven't learned about this yet, but we can also create what are called

anonymous functions that are immediately executed.

And we're going to use that, to improve our code, to make a few changes so

that we can either group all of the logic in one place and

get it out of these methods altogether.

So let's look at how we'll use these concepts.

I'm gonna go back up to the top.

Imagine we had a stored property, a variable named a property,

to which we assign the value, 1.

Now instead of assigning this value 1 directly,

I'm going to assign a function to it.

Now what you see here, just an opening and closing set of braces

that has nothing in it, this is an anonymous function or a closure.

And you'll learn more about this pretty soon, but

essentially think of this as a function without a name right now.

So this works exactly like a normal function.

So inside it, I'm going to return the value 1.

All I've done here is define the function.

And if you check the type of a property, it's the function signature.

So it's a function that does not take any values, no arguments, but

returns an integer.

With regular functions,

when we want to call it, we write the name of the function or the method.

And then using a set of parentheses,

we hold the function, passing in any arguments if the function needs it.

With functions that don't take arguments this means putting an empty set of

parentheses right after the function name to call it.

As you can see here in viewDidLoad.

So it's just the function name and a set of empty parentheses.

Since this function, that we just wrote, is not named, to call it we can place

an empty, or a set of empty parentheses, right after it, immediately after it.

In addition, if we annotate the property, so

we'll say aProperty, explicitly we'll set the type to int.

What we have now is essentially the value 1 being assigned to aProperty.

This is a very roundabout way of simply assigning 1 like we did earlier, but

it opens up some interesting possibilities.

So here we have an anonymous function that returns the value 1,

that is immediately called.

So this executes, and we return 1, and we assign 1 to aProperty.

Using these anonymous functions,

we can group together logic related to our elements, all at the point of creation.

So everything related to the label can be put in this one place.

Let's start and we'll try this with the story label.

So rather than assigning an instance of UILabel directly.

First, we're going to get rid of this instance that we're assigning here.

Make some room so that we can see what's going on.

And again, we're going to explicitly specify the type as UILabel.

Now the reason we're doing this, like we did here with Int,

is because we're assigning a function here.

We need to let the compiler know exactly what it is we're

returning from the function, and what the type of this property will be.

So let's get rid of this, we don't need this anymore.

Now to this property, again,

let's assign an anonymous immediately executing function.

So set of braces just like a function body.

And then right after it,

we'll place the set of empty parentheses to call the function.

Now we have an error, and

that's because this function is expected to return a UILabel value, since

that's what we told the compiler will be the final value that comes out of it.

Now, inside the function, we can set up the instance of the label.

So say let label equal, we'll create a new instance of UILabel.

And then we can go ahead and return it.

And now storyLabel is this instance of UILabel,

except that since this is a function, rather than writing a function below and

assigning the value to this property in viewDidLoad,

we're assigning the function and calling it immediately right here.

So whatever is in this function is executed, and

that value is assigned back to storyLabel.

So inside this function, inside this closure, we can also customize the label.

So we can say label.translatesAutoresizingMaskIntoConst-

raints equal false.

And label.numberOfLines equals zero.

So now that we have this code in here,

this is the same customization we're doing inside viewWillLayoutSubviews.

So if you look here, we're first adding the storyLabel as a Subview,

then we set the number of lines to zero and

turn off the AutoresizingMaskIntoConstraints property.

We've already done that, so we can get these lines of code out of here.

Let's do the same thing, the same basic trick.

It's not really a trick but the same basic thing,

for all of the views that we've added to this view controller.

So instead of assigning an instance of UIImageView, we'll set the type to that

and we'll assign a function that we call immediately.

Inside the body of the function, we'll create a new UIImageView, we'll return it.

So that now we have an instance assigned to the property and

then we can customize this.

So we'll say imageView and we'll do the same basic thing,

translatesAutoresizingMaskIntoConstraints false.

Which means now we can go down to viewWillLayoutSubviews.

Down here, we'll remove this property as well, so

we'll clean it up a little bit more.

We'll go back up and we'll do the same thing for the buttons.

So here we want to set the type.

On firstChoiceButton explicitly to UIButton.

Assign a function that we call immediately.

And in here again, we'll repeat the same basic code that we have.

So let button equal UIButton.

Use the type initializer and specify a .system button.

We'll set the button's AutoresizingMask property to false and return it.

Since this is the exact same way, the secondChoiceButton is set up,

we'll grab all of that and assign it right here.

So now we have all this grouped in one area,

we can go down to viewWillLayoutSubviews.

And we'll remove this and this.

Okay, it's somewhat better.

We've removed some set of code from a different method and

put it in the same place that we're creating the view.

But we didn't get rid of a lot of code.

So in the next video, let's focus on slimming down viewDidLoad even more.