Explore
For Enterprise
Join for Free
Log In

Browse
Search
For Enterprise
Log In
Join for Free

Optional: Closure Idioms Without Closures

Loading...

Programming Languages, Part A

University of Washington

4.9 (1,075 ratings) | 66K Students Enrolled

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. Week 1 of Part A has a more detailed list of topics for all three parts of the course, but it is expected that most course participants will not (yet!) know what all these topics mean.

Skills You'll Learn

Recursion, Higher-Order Function, Pattern Matching, Functional Programming

Reviews

4.9 (1,075 ratings)

5 stars
1,017 ratings
4 stars
51 ratings
3 stars
1 ratings
2 stars
1 ratings
1 star
5 ratings

AL

Mar 22, 2017

Great course!\n\nI think this course has just the right balance of theoretical background, formal definitions, and actual examples to make "just right".\n\nThanks Dan, and everybody else involved!

SK

Mar 24, 2017

An excellent course! Make sure you really have enough time to take this course. There are a lot of videos, but they worth watching. I'd recommend this course to everyone involved in programming.

From the lesson

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.

Introduction to First-Class Functions7:50

Functions as Arguments8:40

Polymorphic Types and Functions as Arguments7:57

Anonymous Functions9:17

Unnecessary Function Wrapping5:05

Map and Filter8:56

Generalizing Prior Topics9:01

Lexical Scope7:22

Lexical Scope and Higher-Order Functions7:37

Why Lexical Scope11:44

Closures and Recomputation6:30

Fold and More Closures11:28

Closure Idiom: Combining Functions9:18

Closure Idiom: Currying10:32

Partial Application9:41

Currying Wrapup6:40

Mutable References8:07

Closure Idiom: Callbacks8:25

Standard-Library Documentation7:00

Optional: Abstract Data Types With Closures11:16

Optional: Closure Idioms Without Closures4:48

Optional: Java Without Closures12:08

Optional: C Without Closures10:56

Taught By

Dan Grossman
Professor

Transcript

[MUSIC] This segment and the next couple, which are all optional fit together and are about taking some of our closure idioms and porting them to languages that don't actually have closures. So the idea here is that closures and higher-order programming Programming with functions like map and filter is great. And it's particularly easy when your language supports closures. Because you can very easily create things with private data, pass them around. Function types are exactly what we want. But if your language doesn't have closures you can still program in this style. Now it's often much more painful. You often have to create what conceptually is your closure environment manually. But by showing you how to do this in languages you might be familiar with we can see some of the connections between different programming styles. So one segment is going to do this in an object oriented style using java, and the key idea there is to have interfaces, that just have one method, so that's kind of like the function code, the call me. Part of an interface of, of a closure. And then in C, where we have function pointers but we don't have closures, we can pass the environment explicitly as an extra argument. So these are optional segments because you need to be a bit of an expert in Java to understand the Java one. And I bit of an expert in C to understand the C one. Even if you do know some Java or C, you may find this a bit over your head, that's okay. I want to put these segments up, so you can refer back to them someday. If you're in these languages, and you find yourself wanting to program in a functional style, then these segments might help you, point you in the right direction. So it shows some connections between the languages and the features It can help you understand what closures and objects are really all about, and at the end of the day it is a bit clumsy so it may make you just wish that more programming languages actually had closures, so that we didn't have to simulate them and incode the same idioms. In more painful ways. So this segment just shows the ML code that we're then going to translate, which is often called porting, to Java or C. It's just a little list library. I'm not going to use ML's built in lists because I want to show all the code, right? And I want to find a fuller comparison because we're going to write everything ourselves in all three languages. And then the next segments are independent. You can watch one or the other or both or neither And then show how to write the same code in those other languages. So here we are. I'm just going to define my own polymorphic data constructor. Alpha my list, two constructors. Cons which has two parts, the head of the list, which is an alpha. And the tail of the list, which is an alpha my list. Or empty for the empty list. These are just plain old constructors. So I can write a function map. I'm using a curried style here, but that's not essential. That takes in a function and one of these my lists, so not ML's built in lists but one of these my lists. If it's empty we return empty. If it's not empty then we cons on F applied to X and mapping F across Xs. That is mapped over the my list type. Filter is similar, it's just the appropriate if then L. I just want to expand this out here so you can see it. Indent it a little more nicely. Empty list is empty list, if f of x, then Cons x onto filtering f across x's, otherwise ignore x and just filter f across x's. And finally, length, which is easier than any of them. Empty list returns zero, non empty list Returns one plus the length of the rest of the list. Then a couple clients that are using these functions to define their own more specific functions. How about something that takes a My List of integers and doubles all the elements. Then we would just use the map function that's no longer quite on the screen, but is above. Remember two curried arguments So I'm doing a partial application here. I'm just calling it with, an anonymous function that takes a number, and multiplies it by 2. And then, how about another function that just takes a, a list. A my list, of course. And, in N. and returns how many. elements of the list are n, okay? And so, one way I could do this in terms of the functions I've written, it's not the most efficient way to compute this but it does work, is to first filter the list. They so that we only have the elements that are n. And then compute its length. Alright? So the result of this called a filter will be a list that has nothing in it but a bunch of the number n. Then however long that number, that list is, is the number of n's that were in the original list. So we're going to write that code in this style, in Java, and C in the upcoming segments.

Explore our Catalog

Join for free and get personalized recommendations, updates and offers.

Coursera provides universal access to the world’s best education, partnering with top universities and organizations to offer courses online.

Products

Certificates
Catalog
MasterTrack™ Certificates
Degrees

Enterprise
Government

Community

Learners
Developers
Beta Testers
Translators
Tech Blog

Coursera

About
Careers
Partners
Press
Blog
Affiliates
Contact
Help

© 2019 Coursera Inc. All rights reserved.

Privacy
Terms
Accessibility
Directory