University of California, Berkeley
EECS Department - Computer Science Division

CS3 Lecture 12 : Higher-Order Functions

---

Overview of today's lecture

• Answers to questions that have come up
• Review
• Higher-Order Functions
  • Introduction
  • every : Do something to every word in a sentence
  • keep : Keep only the words you want
  • accumulate : Combine the words in some way
  • Combine higher-order functions
  • Choosing the right tool (mini-summary)
  • First-class functions and first-class sentences
  • repeated : A function that returns a function!
• Next Time
• Puzzle : I've been had!
• Game : Northcott's Game
• References

Review

• We saw examples of advanced recursion, and saw how it differed from embedded and tail recursion.
• Sometimes there were multiple recursive calls within a procedure!
• Sometimes we had a recursive procedure which called another recursive procedure which called another, etc.
• Overall, Recursion is easily one of the most powerful ideas of the course.
• It's the only thing CS61A cares about as a prerequisite!

---

Higher-Order Functions (chapter 8)

Introduction

• We've seen functions that take functions as input, like number-of-arguments
• Now we'll see many others, and even some that return functions.
• Using these as tools will allow us to solve hard problems by just choosing the combination and composition of the right tools.

every : Do something to every word in a sentence

• (every function sentence-or-word)
  • Domain: Every takes two arguments.
    • The first argument must be a function, and the second is a word or sentence
    • The argument function must take one argument, and its domain must include words. Its range must be words or sentences.
  • Range: sentences. It returns of results from applying function to every element of sentence-or-word
  • This is a mapping pattern
  • You have just seen a function that takes another function as input...like a fish that eats other fish!
  • Examples

keep : Keep only the words you want

• (keep test sentence-or-word)
  • This takes a predicate function and a sentence (or word) as its input
  • Returns: the elements of sentence-or-word that satisfy test
    • If input was sentence, output is sentence
    • If input was word, output is word.
    • (unlike every which always output sentences)s
  • This is a filtering pattern
  • Examples

accumulate : Combine the words in some way

• (accumulate function sentence-or-word)
  • This applies a binary (two-argument) function to a sentence-or-word., two elements at a time.
  • If called on one argument, it returns that argument.
  • Otherwise, the function is applied to the last two elements, then to the third from last and the result of that, etc.
  • or, and are special forms, they can't be used as input!
  • Examples

(accumulate - '(4 3 2 1))
;; ==> (- 4 (- 3 (- 2 1)))
;; ==> (- 4 (- 3 1))
;; ==> (- 4 2)
;; ==> 2

Combine higher-order functions

• HOFs may be combined to form larger, more powerful functions!
• And these can be themselves combined to form even more powerful functions!
• Examples

Choosing the right tool (mini-summary)

• Every maps, or does something to every word in the sentence
  • First argument is a one-argument transforming function
• Keep selects certain elements of a word or sentence and discards the others
  • First argument is a one-argument predicate function
• Accumulate transforms the entire word or sentence into a single result
  • First argument is a two-argument combining function

• (count-if predicate sentence-or-word)
  • which counts the number of elements in sentence-or-word which satisfy the predicate
  • First argument is a one-argument predicate function
  • Built on count and keep
• (all? predicate sentence-or-word)
  • which returns whether all the elements of sentence-or-word satisfy the predicate
  • Built on count-if and count

First-class functions and first-class sentences

• Data is first-class if:
  1. It can be an argument to a procedure
  2. It can be the return value from a procedure
  3. It can be given a name
  4. It can be part of a data aggregate
• In Scheme, words, sentences, booleans and procedures (and some other types you'll see soon) are all first-class

repeated : A function that returns a function!

• This is the first function that we've seen that returns a function
• (Example with foo to warm up)
• (repeated function number)
  • Repeated takes a function and a number and returns a new procedure.
  • The returned procedure is one that invokes the original procedure repeatedly
• Examples

Summary

• Today's big ideas: higher-order functions in detail!
• Smaller ideas: We now have at our disposal many powerful tools which we can plug together to solve a problem

Next Time

• We'll finish the part of this lecture we didn't get to, and after that, look at the reason the MacGambit is shaped the way it is... Lambda!

Puzzle : I've been had!

• Punctuate the following to make a correct english sentence(s):

Game : Northcott's Game [Guy89]

• There is just one checker of each color on each row of the checkerboard
• The Red checker is always to the right of the black checker
• Aside from those constraints, the pieces on the board can be placed randomly
• When it's your turn to move, you slide one of your checkers any numbers of squares in its own row without jumping over your opponent's checker and without going off the board.
• Last person to be able to move wins.

References

• [Guy89] Richard K. Guy "Fair Game", COMAP, Arlington, MA, 1989.

WWW Maven: Dan Garcia (ddgarcia@cs.berkeley.edu) Send me feedback