[MUSIC] This segment of the course is all about first-class functions.
And in this first segment, I just want to give you a little bit of a sense of what
that means, introduce a little bit of a terminology, and actually start by taking
a bit of a step back and asking what is this functional programming stuff that
we've been doing and will continue to do through this segment.
So, functional programming can mean a few different things.
To me, it really is about two concepts that are actually separate.
But for historical and somewhat good reasons, they've been combined together
and we call the result functional programming.
The first we've already studied quite a bit and that's avoiding mutation.
Not using assignment statements, not having data that lives in locations that
can change. We've done a lot of that, we're going to
continue to do that. And we'll even see cases where we don't
want that, where actually mutable state is a reasonable programming idiom.
And then the second thing, which is what this section of the course is all about,
is using functions as values. Passing them around and that sort of
thing, and that'll give you a sense very soon of what we mean by that.
Now, there are a few other things that people often think of when they think of
functional programming and these are not necessarily bad aspects of the definition
of functional programming, if you will. First of all, functional programming
often uses lots of recursion and recursive data structures like lists and
trees and we've seen that in our section so far.
You'll also often see a programming style or even a syntax that's much more
mathematical. the definitions we write down tend to
look much more like the mathematics that we studied in school than other styles of
programming tend to. There is something that some functional
programming languages such as Haskell have, which is laziness.
This is actually a technical term. I'm not saying that anyone is being lazy.
We will study laziness briefly later in the course.
Many courses would emphasize it more than we're going to.
That's just a matter of perspective. And then, there's a lot of definitions
that make a whole lot less sense. sometimes people think that oh, if it's
not object-oriented programming, or it's not C, maybe it's functional programming.
And that's pretty sloppy thinking and we'd like to avoid that one.
Now, once we know what functional programming is, then what is a functional
language? And I've taken to decide that this really
doesn't make a whole lot of sense as a yes or no question.
a functional language is one in which you can do functional programming.
But I think I can do functional programming, as described here, in pretty
much any language. It just might be more or less convenient.
It might be more or less the default. So, to me, a functional language is just
one where functional programming is the easy, natural, conventional way to do it.
All the libraries are generally written in a functional style, and so on.
Alright. So, if this course is not entirely about
functional programming, it's broader than that.
But if that's a big focus and if a big part of functional programming is using
functions as values, it's about time we really got started on that part of the
course. So, a first-class function is, like in
ML, like in many programming languages, a situation where functions can appear and
be used wherever we use other values. Wherever you use numbers or lists or
strings or trees, you could also put functions there.
So, functions can be arguments to other functions.
They can be results of functions. They can be a part of a tuple, you
combine them to variables. You can put them in data type
constructors and so on. So, we're not going to do a lot of code
in this introductory segment, but I thought I would show you just a little
bit of how this really can be done in ML. And, in fact, not using any features that
we didn't already have, just ones we didn't think to use this way.
So, here's two functions. One doubles its argument.
The other increments its argument. That's not very interesting.
But now, let's make a tuple, we're in the tuple,
this is going to be a triple so I'm going to have three parts.
What if in the first part, I put the function double?
So, I'm not calling the function, I'm not passing it an argument, I'm just going to
look double up in the environment, get a function back and put that in the
first part of my tupple. Similarly in the second part, how do I
put increment? And just to contrast the difference
between a function and the result of calling the function what if here I put
double of increment of seven. Now, this third position is going to call
increment with seven, get back eight. Call double with that and get sixteen,
alright? And then, we could even, down here at
about eighteen, we could get out using our old hash one operator that we used
before we learned pattern matching. Hash one of a tuple, that is going to
give back the double function and then we could call it with nine.
So, this is an example of first-class functions because I'm putting functions
in a tuple and then later, I'm pulling them out and using them.
So, let's make sure I got this all right. [SOUND] And show you what the RPL shows
for this. This will be useful to us and this over
here. and sure enough, it says, as we're used
to, double is a function of type int arrow int.
Increment is a function of type arrow int arrow int.
This a_tuple, very interesting.
It is a triple, where the first position holds some function.
The RPL never actually prints out functions, other than to write fn.
The second part is fn and the third part is sixteen, just as I promised.
And the type is a triple int arrow int star int arrow int star int.
And finally, eighteen, where we pulled out the double function from the tuple
and then called it with nine, did actually give us eighteen,
alright? So, that's a little sense of the sort of
thing we'll be doing. And later in this section, after we learn the semantics and
how to use first-class functions, we'll see useful idioms.
The code there was obviously on purpose, just a little bit silly,
okay? So, to finish up, let me just give you a
couple more terms. The most common use of first-class
functions is not putting them in tuples and pulling them out of tuples, although
that can be very useful. The most common is to pass a function as
an argument to another function or as the result of another function.
And when you're doing that, the function that takes or returns other functions is
called a higher-order function. It's just a term.
And higher-order functions are a powerful, powerful idiom for factoring
out common computations and we'll see examples in upcoming segments.
One other term we'll get to later in the section is a function closure.
A function closure is a function that uses bindings from outside the function
definition. Now, how can it do that if it's not an
argument or a local variable, how can it use something?
The same way we always have in ML. Things that are already in the
environment can be used by a function. Once you have first-class functions,
functions being passed around and returned, the way this environment
interacts with the functions is more sophisticated, more interesting, and much
more powerful. We're going to put that off just a bit
and talk about function closures later. So, to me, first-class functions means
functions you can pass around and put anywhere you want.
Function closures means functions that can use things in the environment, not
just arguments and local variables. And these are technically separate
concepts but because functional languages always support both and they're often
used together, use both features together,
these terms are often confused with each other.
And even though it's an important conceptual distinction I'm not going to
harp on the definitions and the terminology because they're so commonly
used incorrectly and it's frankly not that big of a deal.
So, that's our introduction. Hopefully you're excited about the idea
of first-class functions and we'll start learning how to use them for actual
interesting code even in the very next segment.
Dan GrossmanProfessor
