Homework 5: Recipe Aggregator

Overview

A company sells weekly meal kits. A customer sets up a meal plan indicating which recipes they want to make each day and for how many people. The company needs to aggregate this into one shopping list that spans all the recipes. In this assignment, you'll write the code to do this by cleaning each recipe once, keeping the clean recipes in a recipe book, and then scaling and combining recipes from the book, using a combination of table and list operations. You'll also practice testing functions that return tables using properties.

Learning objectives

After this assignment, you should be able to:

• Structure a data-cleaning workflow: load and clean data once, then analyze it
• Combine list and table operations to build a multi-step data pipeline
• Annotate agent-generated code with what it does
• Use property-based testing to validate programs

Setup

• Make a copy of the written answer worksheet and submit the link to it in the worksheet submission form (you can do this before filling anything in).
• Make a copy of hw5-code.arr. The file contains several helper functions, including one that will look up the value in a column of a table based on the value in another column in the table.

The CS111 tables documentation lists the table operations in the dcic2024 context. For lists, you can use filter, map, distinct, length, member, all, any, first, and append. Post to Ed if you think you need something else.

Part 1The Data

A recipe is a table with three columns: the ingredient, the amount, and the unit. Every recipe is written to serve base-servings (4) people. We have given you a google sheet with multiple recipes in separate tabs.

ingredient | amount | unit
---------------------------
Chickpeas  | 2      | cup
garlic     | 2      | clove
Olive Oil  | 3      | tbsp

The meal plan says what to cook this week: the day, which recipe, and how many servings are needed. A recipe can appear more than once in the same meal plan (on different days).

day      | recipe-ref | servings-needed
---------------------------------------
Monday   | dal        | 4
Tuesday  | hummus     | 2

In order to aggregate recipes, we'll need to have the recipes using the same units. The starter code gives you a table called units that indicates how to convert common units into a smaller set (such as "tbsp" to "tsp"). If you write your own test recipes, stick to units in the first column of the units table. There is also a table called densities that converts from grams to teaspoons for common ingredients.

unit | base | per-base          ingredient | g-per-tsp
-----------------------         ------------------------
tsp  | tsp  | 1                 salt       | 6
tbsp | tsp  | 3                 cumin      | 2
kg   | g    | 1000

Part 2Normalizing a Recipe

The recipes were typed by different people, so the data have inconsistencies. Names vary in case ("Onion" vs. "onion"). Salt is in teaspoons in one recipe, tablespoons in another, and grams in a third, and one recipe is entirely metric.

In order to combine recipes, we first need them to use standard capitalization on ingredient names and standard units for the same ingredients. For this part, you'll write a function that takes a recipe and puts it in standard form.

fun normalize-recipe(recipe :: Table) -> Table:
  ...
end

Example: a two-row recipe (the olive oil and salt rows of hummus):

ingredient | amount | unit               ingredient | amount | unit
--------------------------    becomes    --------------------------
Olive Oil  | 3      | tbsp               olive oil  | 9      | tsp
Salt       | 0.5    | tbsp               salt       | 9      | g

Part 3Building a Recipe Book

The company processes many meal plans, and they all draw on the same recipes (dal even appears twice in meal-plan). We shouldn't load and clean a recipe every time a plan uses it. Instead, we'll clean every recipe on the sheet once and keep the results in a recipe book: a list of pages, where each page pairs a recipe's name with its normalized table. We can then reuse the book for every meal plan. The starter file defines the pages for you, and gives you recipe-names, the list of tab names on the sheet:

data Page:
  | page(recipe-name :: String, recipe :: Table)
end

fun load-recipe-book(names :: List<String>) -> List<Page>:
  ...
end

fun find-recipe(book :: List<Page>, name :: String) -> Table:
  ...
end

Part 4Scaling Recipes to the Number of Servings

fun scale-recipe(recipe :: Table, servings :: Number) -> Table:
  ...
end

Part 5Creating a Shopping List

fun shopping-list(plan :: Table, book :: List<Page>) -> Table:
  ...
end

Part 6Property Tests

Let's practice property-based testing a bit more. Here are three properties that we might want on the functions we asked you to write:

• Scaling a recipe keeps the set of ingredients intact
• Scaling a recipe to eight servings doubles the amount for all ingredients
• In a generated shopping list, every ingredient came from one of the recipes in the meal plan.

fun check-same-ingredients(recipe1 :: Table, recipe2 :: Table) ->
Boolean:
  doc: ```determine whether the recipes have the same ingredients, not
  necessarily in the same order```
  ...
end

fun check-doubling(recipe1 :: Table, recipe2 :: Table) -> Boolean:
  doc: ```Check that the second recipe doubles the amount of every
  ingredient in the first recipe```
  ...
end

fun check-ingredients-needed(plan :: Table, book :: List<Page>,
                             shopping :: Table) -> Boolean:
  doc: ```check that every ingredient in the shopping list is
  mentioned in one of the recipes that the plan uses```
  ...
end

To use these checks in testing the other functions on this assignment, you can write checks as follows:

check:
  scaled1 = scale-recipe(my-recipe, 2) # call the function
  check-doubling(my-recipe, scaled1)   # check the property
end

This calls the function that you want to test (scale-recipe), saves the result, and uses the checker to make sure the relationship between the input and output tables hold.

The shopping-list checker takes the meal plan, the recipe book, and the shopping list that was produced from them, so you can write:

check:
  book = load-recipe-book(recipe-names)
  shopping = shopping-list(meal-plan, book)
  check-ingredients-needed(meal-plan, book, shopping)
end

Part 7Reflecting on Working with an Agent

Part 8Stepping Back and Considering the Design

Part 9Copying Over your Check blocks

For the autograder to work, your hw5-tests.arr file should contain ONLY checks for the functions that we told you to write on the handout. Checks on your helper functions should not be copied over (they should stay in your hw5-code file).

Use your favorite AI agent/tool to copy the relevant parts of hw5-code.arr over to a new file hw5-tests.arr. Here's a prompt you can use (you'll also need to upload or paste in your hw5-code.arr file):

I have attached or included a Pyret file named hw5-code.arr. I need a new Pyret file
that contains only some of its tests from the included file, as follows.

Copy over every check block that tests any of these functions:
  normalize-recipe, load-recipe-book, find-recipe, scale-recipe,
  shopping-list, check-same-ingredients, check-doubling, check-ingredients-needed
A check block that also tests other functions should be copied, but with the
lines that test those other functions removed.

Do not copy checks that only test any other function, such as helper
functions. Do not copy any function definitions into the new
file, including the functions listed above.

If a copied check refers to a table, list, or other value that I defined in
hw5-code.arr (for example a test recipe or a test meal plan), copy that
definition into hw5-tests.arr too, above the checks that use it, so that
each check can run without my helper functions. Include only the definitions
that the copied checks need, and do not copy any definition that was given in
the starter code (such as meal-plan, units, or densities). If a definition
refers to one of my helper functions, tell me instead of copying it.

Do not change the text of any check, and do not add new tests.
When you are done, list every check you copied (by block name or its first
line) and every definition you included, and list any checks you skipped
because they test helper functions.

Testing and Grading

For testing, focus on core tests (skip the other kinds) for normalize-recipe, find-recipe, and scale-recipe. We won't be looking at your testing on other functions.

You should also use the property-based tests from part 6, so we can check that you know how to use and write such tests.