pre: <b>10/24. </b>

title: "Iteration"

weight: 20

summary: "Iterate through elements and give our function superpowers."

format:

hugo:

toc: true

output-file: "_index.en.md"

reference-links: true

code-link: true

```{r, include=FALSE}

Iteration allows us to tell R to work on a whole sets of things at once: multiple files, multiple columns, multiple whatever. This can save quite a bit of time. It also lets us to work on problems with dependence, where the decisions of each step depends on the result of the previous step.

For our worksheet today, we are going to be solving some annoyances of the past. I am going to walk you though modifying our `pet_split()` function from last week's functions worksheet to make it even more generalizable.

We are going to be using class survey data for lab today. Please load it in using the following:

Recall from last week that our `pet_split()` function looked at the `pets` column in our `survey` dataframe, and tidy-ed up the column so that instead of having a single character with multiple pets in it, we had a dataframe with `TRUE` and `FALSE` for each pet type, along with "other." You can see the finished function below:

Now, that is cool, but we can make it better. Specifically, if we look at our survey dataframe, we have the exact same problem in our `<DRINK>_days` columns and the `recreation` column. By the end of this worksheet, our `pet_split()` function will work on *any* column with comma separated values.

Our first step is going to be writing the code to accomplish what we want, then we can package it as a function. I've gutted our `pet_split()` function below. We will be starting from that base and working to make it so that we never explicitly call for anything in our code. For example, instead of coding all of the possibilities of pet (dog, cat, fish, bird, reptile, rock, none) inside the function itself, we want to write our code such that it can accept *any* list of possibilities as an argument and work from that.

The first step of our current code is to create a dataframe for our outputs. We still want to do that, but without us defining each possibility ourselves inside the function. Instead, we will provide a vector of possibilities, and have R iterate through those to make our columns. We can use a `for()` loop for that.

First, we'll create a vector of our possibilities, in this case our pets:

Next, we need code to iterate through those possibilities, and create a dataframe from them. We'll start with making what we know, a column for IDs which has as many rows as our intended input, `pet_vector` from above. Next, we will iterate through all possible options, and make a new column for each. Here I iterate through our `possible_columns` vector, and for each element (`option` in the loop) I create a column of `NA`s.

If we look at out output now, it is *exactly* the same as if we made each column ourselves, but now it is done by providing a vector of options. *And we can change those options to whatever we want*. This will come in handy later.

Our next step, as before, is to test for each possible option and fill in the respective columns. We will use iteration here as well.

::: {.question}

Using the same principle as above, iterate over each option in `possible_columns` and use `grepl()` to test if the pet appeared in that case. Fill the respective columns. *Make sure that `pet_vector` and `possible_columns` are reset to normal before you try!*

:::

```{r, include=answers, results='asis', echo=FALSE}

Once we have our "knowns" taken care of, we can work on the others. The process is nearly identical, just swap `grepl()` with `gsub()` and apply it to `pet_vector` like before.

::: {.question}

Iterate over each option in `possible_columns` and use `gsub()` to remove all of our known possibilities (and commas) from `pet_vector`. You can then use `trimsws()` to remove the extra spaces. Assign the remaining values to the "other" column of `pet_output`.

:::

```{r, include=answers, results='asis', echo=FALSE}

If we look at our code all together now, it looks like the following. If we run it, it will return the exact same thing as our old `pet_split()` function, but instead of each option being hand-coded by us, it knows how to work with any given vector of options and create our desired output.

If we turn it into a function, it will look like this:

That's pretty cool, but what do you think would happen if we tried it on another column?

While it now has a bit of an odd name, our function can now work on *any* column! It is hard to express how big of a deal that is. We now have a single general tool that can adapt itself to several situations. The input is *arbitrary*, as long as it is formatted the same way (values separated by commas), we can put *anything* through this function and get a nice tidy dataframe back. A whole new universe of possibilities just opened.

::: {.question}

Try our function on some other columns in the `survey` dataframe!

:::