So we know how go create higher order functions by passing a function as

an argument.

Another way to create one of these higher order functions is to return a function

from a method just like you would a value.

You can use this approach as a function factory of sorts.

This allows you to configure how the function works from the outside.

So our problem is we wanna take any date string, process it, and

return another date string.

But we want to create that function on the fly.

As we saw before we can use the date time formatters to help us out.

Let's do this.

Okay so let's make our method.

So let's see, it's going to return a function like we said, right?

So it's gonna be public static is gonna return a function that

takes a string of a formatted date.

And then it's gonna return a string, some other string, another format okay.

And let's say createDateStringConverter.

Okay, so that's pretty clear.

It'll create one of these.

So we know that it can take a formatter for the way in, so

we'll call that an inFormatter.

And then let's do one for out so we'll do a date, time, formatter out.

Let's out these on two separate lines,

make that a little bit cleaner.

Space wise, let's get some more space here.

Out(Formatter).

Okay, and we said what we'll do is we'll return a function.

Okay, so we'll return, and that function's gonna take a string, take a bait string.

And in the body here, what we'll do is we'll parse that.

So the function itself will return a LocalDateTime.

What we'll do is we'll parse that date string that came in

using our inFormatter, right?

So we know what the format is coming in.

And then finally, we'll format using our outFormatter.

Cool, and so this requires that cuz we're returning a function.

So that seems pretty cool, right?

I'm gonna go ahead let's use it.

I'm gonna take let's get rid of this, all this code here cuz we're gonna recreate

that pretty easily with our function now.

So let's get rid of that and let's make a new one of those.

So we're gonna get back a function that takes a string and returns a string.

And we'll call it converter.

And we'll say createDateStringConverter.

And on the input side, we know that that is .RFC, right, there it is.

And then for the output,

let's just do some other one will say basic ISO DateTime.

Cool. And instead of mapping to that,

we'll map to a converter.

And cool, it worked.

Let's go ahead. I'm just gonna change this just to make

sure it's not the default there.

Show off, awesome.

Now wait a second, let's go look at that method again.

So you'll notice that these formatters are coming in in the method scope, right?

And we're using them inside the lambda here which is

in the scope of this method until we return it.

Does that mean that these formatters or

some hell still in scope when we get up here?

Right this will just float away.

This one will be an existence on scope but when we use this converter it's there.

It surely must mean that right away in that scope.

So what this creates is known as a closure.

These variables, these inFormatter and outFormatter are captured and

they're available to the function itself for later when the code runs.

Remember, this code is lazy and it hasn't ran yet but

it will some time in the future when something calls the apply method.

So therefore,

it needs those variables to execute those variables are stored in lexical scope.

Here, actually, let's explore it a bit more.

In the creation of that method, I'm gonna just go ahead and

in the method body here, we'll make a new local variable in the method scope.

And it will go away when the method ends, just like normal, right?

So let's do the meaningOfLife, this is handy if this is something that

takes a long time to calculate, which it does.

And of course, the meaningOfLife is 42.

So to show this off, I'll use it in here, right.

So we'll just, we're returning a string here,

let's just return something at the front.

We'll do the meaning of life, And

we'll just add some information, a little dash there.

Okay, therefore, right, this is very clear, this would normally fall off,

we're gonna use it.

And then later we're gonna use it, and

look at that it's outside of the scope, right.

When this function's called here, that should be gone but

it's captured, it's pretty cool, right.

So the variable is in the scope of the function.

But what happens if that variable changes, what if I increment the meaningOfLife?

Well look at this, see what this says.

Variable used in lambda expression should be final, or effectively finally.

There's an intention action, let's see what it says.

It says copy meaningOfLife to effectively final temp variable.

It's all temporary indeed, let's do it.

Okay, so see what it did?

It made a new variable called finalMeaningOfLife and we used it here.

This sort of problem was around in Java 7 as well, and

you used to have to mark the variables themselves as final and

they wouldn't changed if you closed over them using an abstract class.

With Java 8 they made it a little bit more loose but

they checked that you don't change it.

So this version is okay and it's trying to protect us from

breaking the pure function principal of relying on side effects, right?

However, let's break some big time rules.

So let's undo that last little change there and

let's move the meaningOfLife inside the function body and then we'll increment it.

I just heard you yell.

Wait a second Craig, that's producing a side effect,

you just broke a pure function.

Well nice eyes, I shouldn't be modifying this value should I?

And it looks like the squiggle agrees.

So let's see what this intention action is.

So it says transform meaningOfLife into a final one element, what the,

let's just do it, let's see what happens.

Yuck, now we know.

We shouldn't do this because it makes the function impure, right?

No side effects but yuck, look at that.

I really wish intelligent didn't provide this solution,

this is very obviously a hack.

And there is most certainly a better way to work around those issue.

Let's remove the limit, I wanna show you something here.

Let's come up to this limit here, I'm gonna remove this so

that we can just take a look.

Let me go ahead and I'm gonna run this and we'll see that it appears to work.

So we counted all the way up to 1042, cuz there is 1000 job postings,

and it's going in order, all the way through.

You might even argue that that worked correctly.

But if we were trying to show how many times it ran, like if we

were really trying to keep track of this meaningOfLife as an increment and

we wanted to see has it gotten better?

Remember when we talked about being able to run these streams in parallel?

Parallelization is out of the scope of this course,

because I need more practice saying it.

But first, I'll give you a little taste.

So if I simply switch this call here to stream to be called parallelStream.

Parallelalized, what it will do now is it will spread its execution over a number of

cores available on your machine.

So now when I run this, check this out.

The numbers are all goofed up, right?

So they're not going in order.

And that's because each core is taking this functions and running them across.

See when I run this now?

The number is jumping all over the place.

Right, if we were doing something without side effects outside or

just trying to print an order, this could be disastrous.

So I'm gonna back that up.

I do not like this we're no, we're gonna keep that function pure.

The meaningOfLife is important.

Let's get the meaning of life over there.

Let's put that back.

So Java makes sure that the values we capture here are effectively final,

follow its lead and keep things pure.

The closures are so cool and they let you capture values that are effectively final.

Now, this is super handy in helping to create configured functions,

just like we did here.

Because our function is lazy, it needs to hold on to that lexical scope, so

can use it whenever it's called.

Speaking of lazy that is the last item in

our parking lot and you got this one, right?

Streams are lazy, they are waiting will be called upon and

the only one called upon then they do work, right?

You pass around powerful functions that are lazily awaiting you to execute them.

You though, you are not lazy.

You made it all the way here to the end of the course.

I am very impressed with your dedication.

Let's wrap things up right after this quick break.