[00:00:00]

>> Kyle Simpson: Let's talk about part two of the exercise. So if we're starting
from this as our solution, we can start to convert these regular functions that are
declarations or expressions into arrow functions. Using the various things we know
about error functions syntax. So for example, get students from ID could be created
as getStudentFromId, and it's gonna taken that.

[00:00:32]
And it's going to return the student studentRecords.find(), and here's another
function expression that we wanna do with an arrow function. So that one is record,
and then this expression. And that's how we find it. So, that's our definition for
the arrow function as compared to the stand alone function.

[00:01:17]
We'll do the same technique with print records.
>> Kyle Simpson: And rather than making a function block, I can actually see that
all three of these functions are chainable. Since sort will retain the array and
since the array will be a local array, the mutation won't matter in this particular
case.

[00:01:44]
So I can take advantage of that by simply saying recordids.map(getStudentFromId),
and then I can say .sort. And here, we have another function that we should convert
to an array function. But this whole If, else, if thing can be done as a ternary,
so we don't need a function body.

[00:02:07]
So let's write it as the arrow function that takes in record1 and record2. And we
will use a ternary and I will write it all on one line because why not. That was a
joke, you were supposed to laugh at that. Record1.name is less than Record2.name,
then we return -1.

[00:02:36]
Otherwise (record1.name > record2.name), we return 1 otherwise 0. So that's our
error function that we called the sort on. And then finally we call the .forEach,
and again, we have this Function which is receiving a record and calling console
log. Since console log is a function call, it's suitable as an expression which
means we don't need an arrow function body.

[00:03:05]
So we can simply say record and then call the console.log, and, since I'm lazy, I'm
just gonna copy it. I don't wanna retype it.
>> Kyle Simpson: And there is our arrow function representation of print records.
>> Kyle Simpson: Paid students to enroll
>> Kyle Simpson: It doesn't receive anything, so it's an arrow function.

[00:03:42]
And again, I can see that what I'm ultimately doing is returning an array. So I can
just simply return that array, and then have Included in the array what's going to
happen through chaining. So, that and I'm going to spread out this expression. And
this expression will start with studentRecords.filter and here we are with another
online function expression that can be arrow function.

[00:04:15]
So I'll write an arrow function. Takes in record and since I'm being lazy, I'm
gonna copy that. There's our arrow function. After filter, we can simply call the
dot map, change directly off of it. We have another inline function called, "Get
student I-D". It simply returns record. This is everybody's favorite arrow function
which just does that.
[00:04:43]
And that array then gets spread out. It's a list of I-Ds that gets spread out into
this array that's returned from paid students to enroll. So there is our arrow
function.
>> Kyle Simpson: And now, finally, remind unpaid is an arrow function that takes
record IDs and it Does recordIds.filter, and we have a student ID arrow function or
parameter called studentId that comes in.

[00:05:26]
And we can, again, avoid needing an arrow block by doing a property chain off the
function call. So we can simply say, getStudentFromId(studentId), and then access
the property off of that call, and negate it. And then, we can call printRecords
>> Kyle Simpson: With that input.
>> Kyle Simpson: So there is that arrow function, and yay!

[00:06:08]
No more regular functions, only arrow functions.
>> Kyle Simpson: Any questions about part two of the exercise?
>> Kyle Simpson: Yes?
>> Speaker 1: There was a moment with the multiple ternary as the callback
function, the chained array method, it's like-
>> Kyle Simpson: Yeah, the one that I put all [CROSSTALK]
>> Speaker 1: I was like, surely that's just a rhetorical gesture that he created
inside.

[00:06:37]
Then I realized, I had written something like it two weeks ago. I was like, God.
>> Kyle Simpson: Yeah, I know, my observation of those that like to write arrow
functions is that there is a predisposition to use the most concise syntax
possible, using whatever tricks you possibly can. Including Inline ternaries that
are nested together, using the comma operator to nest expressions.

[00:07:07]
I've seen people define parameters in the arrow parameter list that are unused
variables so that they don't have to declare a variable to use inside of their
expression. I mean, any sort of syntactic trick you can use to get it down to a
concise arrow expression seems to be the norm.

[00:07:32]

>> Kyle Simpson: Okay, so hopefully you now feel a little bit more with some
slightly more real worldish code. Some idea about the differences between the
functions that we can create as declarations, as inline function expressions, and
now even as arrow function expressions. You have some side by side comparison that
you can make.

[00:07:54]
Make your own determinations on whether or not these styles are more readable, or
more maintainable, for your purpose.