Unit 3 Lab 2: Contact List, Page 5

Morgan, Jasmine, and Omar are building an initials from name block that accepts one contact as input and reports that person's initials.
initials from name (name from contact( (item (1) of (contact list)) reporting 'BA'

initials from name (name from contact( (item (1) of (contact list)) reporting 'BA'

Jasmine: I used the split () by ('pink dot indicating a space character')

block to break up the contact's full name into a list of their names, and then I joined the first letter of each name:
initials from contact: (contact) {
script variables (list of names)
set (list of names) to (split (name from contact (contact)) by (word))
report (join (letter (1) of (item (1) of (list of names))) (letter (1) of (item (2) of (list of names))) )
}

initials from contact: (contact) {
script variables (list of names)
set (list of names) to (split (name from contact (contact)) by (word))
report (join (letter (1) of (item (1) of (list of names))) (letter (1) of (item (2) of (list of names))) )
}

What's the difference between splitting by spaces and splitting by words?

Try it! (Each brown dot represents a space.)

In one case, split is focusing on the exact characters in the string. In the other case, it's giving you what you really want: the words in the contact's name. At a low level of abstraction, text is made of characters and you look through each of the characters. But at a higher level of abstraction (such as when you are reading), text is made up of words. Snap! lets you think at this higher level of abstraction.

Morgan: But what about someone who goes by three names like Martin Luther King? It would just report "ML" for him.

Omar: Oh, that's because the block only takes the first letter of items 1 and 2. We have to add in letter (1) of (item (3) of (list of names)).

Jasmine: But what if someone has more names than that? In my aunt's family they each have five or six names...

Omar: Well, then we need to take letter (1) of each item in the list of names. That sounds as if what we need is a higher-order function. Higher-order functions are good at doing things with individual items in a list.

A higher-order function is a function that takes a function as input (or reports a function as output).

Build and experiment with these examples of the map function.
Discuss and then explain in writing what these expressions are doing.

The

map 'reporter input slot' over 'list input slot'

block takes two inputs: a function (a reporter with a blank input slot) and a list, and it reports a new list in which each item is the result of calling the function with an item from the original list as input. For example:
map (join( )(s)) over (list {cat, dog, bird}) reporting {cats, dogs, birds}

map (join( )(s)) over (list {cat, dog, bird}) reporting {cats, dogs, birds}

map (round ( )) over (list{3.14159, 87, 5.4}) reporting {3, 87, 5}

You choose the function that describes the result for one input item, and map applies that function to each item in the input list and then reports the list of result values. If your function has item 1 of or item 2 of in it, you're probably trying to do map's part of the job.

Map is a higher-order function just like keep and combine. The function mapped over the list always has a blank input slot. This is where the list item goes each time the function is performed.

This picture shows how the three higher-order functions could be used:
picture of map transforming each item, keep blocking some input items so they don't appear in the result, and combine superimposing them into one icon
See the higher-order function expressions with these (imaginary) shape procedures.

map (shade figure ()) over (list of figures)

keep items (is () a polygon?) over (list of figures)

combine (list of figures) using (overlay ())

Here is a quick review of the higher-order functions map, keep, combine.

Map performs a function on every item of a list and reports the list of changed items.
Keep uses a predicate function (a true/false question) to check every item in a list and reports the items that make the predicate true. (You learned about keep on Unit 2 Lab 3 Page 5: Keeping Items from a List.)
Combine uses a combining function (a function with two inputs) to report the results of combining all the items in a list using that function. (You learned about combine on Unit 2 Lab 4 Page 3: More Mathematical Reporters.)

If it isn't open already, open your U3L2-ContactList project.
Use map and combine together to build an initials from name reporter that takes a name as input and reports that person's initials.
Test and debug your initials from name block.
Create an expression to report a list of the initials of all your contacts.

Need a hint?

First, create an expression to report a list of the names of all your contacts.
→

→
Which of the following statements are true about this list?

reports the list {r, 5, b, i, 3, k, 2, 3, t, 6}.

Correct.

reports the list {rabbit}.

The blank space in item of expects a list as its input, but map puts a single item from words and numbers into that slot.

Both of the above.

The input list (words and numbers) contains text strings (not lists) so the blank space in the input function should expect a text string (not a list).

None of the above.

Map performs the input function over each item in the input list.
Which of the following statements are true about this list?

Choose all that apply.
Why not use an ADT?

The list inside a list shown above makes it clearest to you now as you answer this self-check item what the structure is, but you're right, in an actual program it would be better to use an abstract data type:

reports the list {Augusta, Boise, Columbia, Des Moines}.

Correct.

reports the list {Augusta, Maine}.

No. Map performs the input function on each item of the list—not on the whole list. The expression item (1) of (capitals) (without using map at all) would report the list {Augusta, Maine}.

reports the list {A, B, C, D}.

No. You can find the first letter of a word, but not the first letter of a list. The expression map (letter (1) of (item (1) of ( ))) over (capitals) would report the list {A, B, C, D}.

reports the list {Maine, Idaho, South Carolina, Iowa}.

No. This is a tricky one. What gets reported is actually a list of one-item lists: {{Maine}, {Idaho}, {South Carolina}, {Iowa}}. You might want to try it in Snap!. The expression map (item (2) of ()) over (capitals) would report the list {Maine, Idaho, South Carolina, Iowa}.

reports the list {{Boise, Idaho}, {Columbia, South Carolina}, {Des Moines, Iowa}}.

No. Map performs the input function on each item of the list—not on the whole list. The expression all but first of (capitals) (without using map at all) would report the list of lists {{Boise, Idaho}, {Columbia, South Carolina}, {Des Moines, Iowa}}.
Read the two scripts below; they do the same thing. Give two reasons why the use of abstraction in the second example is preferred.
This new multiple-choice quizlet misbehaves if you only select some of the correct responses. Need to fix. --MF, 1/13/21

Consider this list of squares:

Which of the following expressions will report a list? Choose all that apply.

Correct.

Correct.

No, + reports a number, so in this case combine will report a number.

Correct.

No. join(1,4) will report 14.

Correct.

Click the picture to load this database project:

Data from Structure and Interpretation of Computer Programs by Abelson and Sussman. Creative Commons licensed.

This is the list of employees of a small company. Each of the smaller lists contains a person's name, job title, and yearly salary.
"This company spends more money on the big bosses than on the people who do the work," says Alyssa one day. Is she right? Write an expression to compute the total salaries of everyone paid less than $100,000 per year. Then find the total for everyone paid more than $100,000 per year.
Ben suggests that the results will be more convincing in the form of a list containing that total and all the names of the people in that category (paid less than $100,000, for example). So, if there are five people in that category, your list will have six items: first the total of the salaries, and then the names of the people. Try this both for less than $100,000 and for more than $100,000.
Find the average salary of people paid less than $100,000 per year.

Transforming Every List Item