Introduction to First-Class Functions

Loading...

來自 University of Washington 的課程

程序设计语言

851 個評分

University of Washington

程序设计语言

851 個評分

This course is an introduction to the basic concepts of programming languages, with a strong emphasis on functional programming. The course uses the languages ML, Racket, and Ruby as vehicles for teaching the concepts, but the real intent is to teach enough about how any language “fits together” to make you more effective programming in any language -- and in learning new ones. This course is neither particularly theoretical nor just about programming specifics -- it will give you a framework for understanding how to use language constructs effectively and how to design correct and elegant programs. By using different languages, you will learn to think more deeply than in terms of the particular syntax of one language. The emphasis on functional programming is essential for learning how to write robust, reusable, composable, and elegant programs. Indeed, many of the most important ideas in modern languages have their roots in functional programming. Get ready to learn a fresh and beautiful way to look at software and how to have fun building it. The course assumes some prior experience with programming, as described in more detail in the first module. The course is divided into three Coursera courses: Part A, Part B, and Part C. As explained in more detail in the first module of Part A, the overall course is a substantial amount of challenging material, so the three-part format provides two intermediate milestones and opportunities for a pause before continuing. The three parts are designed to be completed in order and set up to motivate you to continue through to the end of Part C. The three parts are not quite equal in length: Part A is almost as substantial as Part B and Part C combined.

從本節課中

Section 3 and Homework 3 -- and Course Motivation

This section is all about higher-order functions -- the feature that gives functional programming much of its expressiveness and elegance -- and its name! As usual, the first reading below introduces you to the section, but it will make more sense once you dive in to the lectures. Also be sure not to miss the material on course motivation that we have put in a "lesson" between the other videos for this week and the homework assignment. The material is "optional" in the sense that it is not needed for the homeworks or next week's exam, but it is still very highly encouraged to better understand why the course (including Parts B and C) covers what it does and, hopefully, will change the way you look at software forever.

與講師見面

Dan Grossman
Professor
Computer Science & Engineering

[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.

探索我們的目錄

免費加入並獲得個性化推薦、更新和優惠。

Coursera 致力於普及全世界最好的教育，它與全球一流大學和機構合作提供在線課程。

© 2018 Coursera Inc. 保留所有權利。

通過 App Store 下載

通過 Google Play 獲取