We want to rewrite the function cc so that its second

We want to rewrite the function cc so that its second argument is a list of the values of
the coins to use rather than an integer specifying which coins to use. We could then have
lists that defined each kind of currency:
const us_coins = list(50, 25, 10, 5, 1);
const uk_coins = list(100, 50, 20, 10, 5, 2, 1);
We could then call cc as follows:
cc(100, us_coins);
292
To do this will require changing the program
cc
somewhat. It will still have the same form,
but it will access its second argument differently, as follows:
function cc(amount, coin_values) {
return amount === 0
? 1
: amount < 0 || no_more(coin_values)
? 0
: cc(amount, except_first_denomination(coin_values)) +
cc(amount - first_denomination(coin_values), coin_values);
}
Define the functions
first_denomination
,
except_first_denomination
, and
no_more
in terms of primitive operations on list structures. Does the order of the list
coin_values
affect the answer produced by cc ? Why or why not?

90 Chapter 2 Building Abstractions with Data
Exercise 2.20
In the presence of higher-order functions, it is not strictly necessary for functions to have
multiple parameters; one would suffice. If we have a function such as plus that natu-
rally requires two arguments, we could write a variant of the function to which we pass
the arguments one at a time. An application of the variant to the first argument could
return a function that we can then apply to the second argument, and so on. This prac-
tice—called currying and named after the American mathematician and logician Haskell
Brooks Curry—is quite common in programming languages such as Haskell and OCaml.
In JavaScript, a curried version of
plus
looks as follows.
function plus_curried(x) {
return y => x + y;
}
Write a function
brooks
that takes a curried function as first argument and as second
argument a list of arguments to which the curried function is then applied, one by one,
in the given order. For example, the following application of brooks should have the same
effect as plus_curried(3)(4) :
brooks(plus_curried, list(3, 4));
7
While we are at it, we might as well curry the function
brooks
! Write a function
brooks_curried
that can be applied as follows:
brooks_curried(list(plus_curried, 3, 4));
7
With this function brooks_curried , what are the results of evaluating the following two
statements?
brooks_curried(list(brooks_curried,
list(plus_curried, 3, 4)));
brooks_curried(list(brooks_curried,
list(brooks_curried,
list(plus_curried, 3, 4))));
Mapping over lists
One extremely useful operation is to apply some transformation to each element in
a list and generate the list of results. For instance, the following function scales each
number in a list by a given factor:
function scale_list(items, factor) {
return is_null(items)
? null
: pair(head(items) * factor,
scale_list(tail(items), factor));
}
scale_list(list(1, 2, 3, 4, 5), 10);
[10, [20, [30, [40, [50, null]]]]]

2.2.1 Representing Sequences 91
We can abstract this general idea and capture it as a common pattern expressed
as a higher-order function, just as in section 1.3. The higher-order function here is
called map . The function map takes as arguments a function of one argument and
a list, and returns a list of the results produced by applying the function to each
element in the list:
function map(fun, items) {
return is_null(items)
?