Functional programming

class: title-slide

# Functional programming

## with `purrr`

.center[<img src="img/00/logo_purrr.png" width="100px"/>]

### A. Ginolhac | rworkshop | 2021-09-10

<div>
<style type="text/css">.xaringan-extra-logo {
width: 110px;
height: 30px;
z-index: 0;
background-image: url(img/00/logo_uni_elixir.png);
background-size: contain;
background-repeat: no-repeat;
position: absolute;
bottom:1em;left:1em;
}
</style>
<script>(function () {
  let tries = 0
  function addLogo () {
    if (typeof slideshow === 'undefined') {
      tries += 1
      if (tries < 10) {
        setTimeout(addLogo, 100)
      }
    } else {
      document.querySelectorAll('.remark-slide-content:not(.title-slide):not(.inverse):not(.hide_logo)')
        .forEach(function (slide) {
          const logo = document.createElement('a')
          logo.classList = 'xaringan-extra-logo'
          logo.href = 'https://rworkshop.uni.lu/'
          slide.appendChild(logo)
        })
    }
  }
  document.addEventListener('DOMContentLoaded', addLogo)
})()</script>
</div>

---
# Learning objectives

.flex[
.w-60.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.ml6[
.large[.gbox[You will learn]]

.float-img[![](img/00/kt.png)]

.Large[
- Functional programming approach to focus on `actions`
- Iteration machinery done by someone else
- Pass `functions` as `arguments` to higher order functions
- Use `map()` to replace `for` loops

]]]

---
class: middle, inverse, center

# Reminders

---

# Vectors

.left-column[

**Atomic** means only one type of data

- The type of each atom is the .bold.Large[same]
- The size of each atom is .bold.Large[1] (single element)

- is the .bold[conversion] between types
- can be
    + **explicit** (using `as.*()` functions)
    + **implicit**

]

.right-column[

```r
# Logical
c(TRUE, FALSE, TRUE)
```

```
[1]  TRUE FALSE  TRUE
```

```r
# double
c(1, 5, 7)
```

```
[1] 1 5 7
```

```r
# automatic coercion
str(c(1, 5, 7, "seven"))
```

```
 chr [1:4] "1" "5" "7" "seven"
```

```r
# volontary coercion
as.character(c(1, 5, 7, "seven"))
```

```
[1] "1"     "5"     "7"     "seven"
```
]

.footnote[Adapted from the [tutorial](https://jennybc.github.io/purrr-tutorial/ls03_map-function-syntax.html) of .bold[Jennifer Bryan]]

---

# Lists as trains

.pull-left[
#### The steam machine is the `list()` structure
![](img/map_train.png)

![](img/map_train_single.png)
]

.pull-right[
#### Sub-selection

![](img/map_train_multiple.png)
]

.footnote[from [Advanced R, second Ed.](https://adv-r.hadley.nz/) by .bold[Hadley Wickham]]

---

# Actions: functions

.pull-left[

### Declared function

```r
my_function <- function(my_argument) {
  my_argument + 1
}
```

- Is defined in the global environment
    
    ```r
    ls()
    ```
    
    ```
    [1] "my_function"
    ```
    
    ```r
    ls.str()
    ```
    
    ```
    my_function : function (my_argument)  
    ```

- Is reusable
    
    ```r
    my_function(2)
    ```
    
    ```
    [1] 3
    ```
]

.pull-right[

### Anonymous functions

- Are not stored in an object and are used "on the fly"

```r
(function(x) { x + 2 })(2) # (\(x) x + 2)(2)
```

```
[1] 4
```
- Does not alter the global environment
    
    ```r
    ls()
    ```
    
    ```
    [1] "my_function"
    ```
    
    ```r
    # remove the previous my_function to convince you
    rm(my_function)
    (function(x) { x + 1 })(2)
    ```
    
    ```
    [1] 3
    ```
    
    ```r
    ls()
    ```
    
    ```
    character(0)
    ```
]

---
class: middle, center, inverse

![](img/00/logo_purrr.png)

.flex[
.w-70.ml6[
### .large[purrr] enhances R with consistent tools for working with functions and vectors

.large[
> .Large[Functional programming] [...] treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data

.tr[
— _Wikipedia_]
]]]

---

# Function, the LEGO figures example

#### Consider a hypothetic `put_on` function

.flex.justify-center[
.w-25.mh5.mt3.ml3[
![legos](img/map_lego_single.jpg) 
]
.w-25.mh2.ph3.mt5[
.huge.bold[+]
]
.w-25.mh5.mt3[
![antenna](img/map_lego_antenna.jpg)
]
.w-25.mh2.mt5[
.huge.bold[=]
]
.w-25.mh5.mt3.mr3[
![lego with antenna](img/map_lego_single_antennate.jpg)
]
]

.center.Large[`put_on(figures, antenna)` returns a LEGO figure with antenna]

.footnote[Figures LEGO pictures courtesy by .bold[Jennifer Bryan]]

---

# Iteration, the LEGO figures example

#### Illustration for .bold[several] legos, how to apply `put_on()` to more than 1 input?

.flex.justify-center[
.w-40.mh5.mt3.ml3.mt4[
![legos](img/map_lego.jpg)
]
.w-25.mh2.ph3.mt5[
.huge.bold[+]
]
.w-25.mh5.mt4[
![antenna](img/map_lego_antenna.jpg)
]]

.flex.justify-center[
.w-40.mh2.mt3.ml5[
.Large[`put_on(figures, antenna)`]
]
.w-15.mh2.mt3[
.huge.bold[=]
]
.w-30.mh5.mr5[
![figures with antennas](img/map_lego_antennate.jpg)
]]

.footnote[[LEGO figure pictures from Jennifer Bryan](https://github.com/Jenniferbc/lego-rstats)]

---

# Back to R programming

.pull-left[
### For loop approach

```r
out <- vector("list", length(legos))
for (i in seq_along(legos)) {
* out[[i]] <- put_on(legos[[i]], antenna)
}
out
```
]

.pull-right[
### Functional programming approach

- named function

```r
antennate <- function(x) put_on(x, antenna)
map(figures, antennate)
```

- anonymous function

```r
map(figures, function(x) put_on(x, antenna))
```
]

.flex[
.w40.ml4.mr6[
.huge[
>Of course, someone has to write loops. It doesn't have to be you.

.tr[
— _Jenny Bryan_]]
]]

---
class: slide-practical

# Your turn
<div class="countdown blink-colon noupdate-10" id="timer_61449560" style="bottom:0;left:33%;margin:3%;padding:15px;" data-warnwhen="1">
<code class="countdown-time"><span class="countdown-digits minutes">04</span><span class="countdown-digits colon">:</span><span class="countdown-digits seconds">00</span></code>
</div>

.flex[
.w-50.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.ml2[
.large[.gbox[Questions <svg aria-hidden="true" role="img" viewBox="0 0 384 512" style="height:1em;width:0.75em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M202.021 0C122.202 0 70.503 32.703 29.914 91.026c-7.363 10.58-5.093 25.086 5.178 32.874l43.138 32.709c10.373 7.865 25.132 6.026 33.253-4.148 25.049-31.381 43.63-49.449 82.757-49.449 30.764 0 68.816 19.799 68.816 49.631 0 22.552-18.617 34.134-48.993 51.164-35.423 19.86-82.299 44.576-82.299 106.405V320c0 13.255 10.745 24 24 24h72.471c13.255 0 24-10.745 24-24v-5.773c0-42.86 125.268-44.645 125.268-160.627C377.504 66.256 286.902 0 202.021 0zM192 373.459c-38.196 0-69.271 31.075-69.271 69.271 0 38.195 31.075 69.27 69.271 69.27s69.271-31.075 69.271-69.271-31.075-69.27-69.271-69.27z"/></svg>]]

.large[
Calculate the `mean` of each column of the `swiss` dataset, which is packaged with base `R`.
]
]

.w-50.bg-washed-blue.b--blue.ba.bw2.br3.shadow-5.ph3.mt3.ml2[
.large[.ybox[Tips]]
- `purrr::map()` expects 2 arguments:
    1. a `list`
    1. a `function`
- a data frame is a list
- Each column represents an element of the list _i.e._ a **data frame is a list of columns**
]]

---

# Answer

.pull-left[
### Functional programming focuses on actions

```r
map(swiss, mean) %>%
  str()
```

```
List of 6
 $ Fertility       : num 70.1
 $ Agriculture     : num 50.7
 $ Examination     : num 16.5
 $ Education       : num 11
 $ Catholic        : num 41.1
 $ Infant.Mortality: num 19.9
```

]

.pull-right[
### The for loop machinery

```r
means <- vector("list", ncol(swiss))
for (i in seq_along(swiss)) {
* means[i] <- mean(swiss[[i]])
}
# need to manually add names
names(means) <- names(swiss)
means %>%
  str()
```

```
List of 6
 $ Fertility       : num 70.1
 $ Agriculture     : num 50.7
 $ Examination     : num 16.5
 $ Education       : num 11
 $ Catholic        : num 41.1
 $ Infant.Mortality: num 19.9
```
]

---
class: nvs1

# For loops are fine

.flex[
.w-50.bg-washed-red.b--red.ba.bw1.br3.shadow-5.ph3.mt1.mr1[
.large[.rbox[Growing vector]]

```r
for_loop <- function(x) {
  res <- c() # initialize an empty vector
  for (i in seq_len(x)) {
    res[i] <- i
  }
}
```
]
.w-50.bg-washed-green.b--green.ba.bw1.br3.shadow-5.ph3.mt1.mr1[
.large[.gbox[Correct memory allocation]]

```r
for_loop <- function(x) {
  res <- vector(mode = "integer", length = x)
  for (i in seq_len(x)) {
    res[i] <- i
  }
}
```
]]

.flex[
.w-50.bg-washed-yellow.b--yellow.ba.bw1.br3.shadow-5.ph3.mt1.mr1[
.large[.gbox[Using `Rcpp`]]

```r
library(Rcpp) # binds cpp compilation to R
cppFunction("NumericVector rcpp(int x) {
  NumericVector res(x);
  for (int i=0; i < x; i++) {
    res[i] = i;
  }
}")
```

]
.w-50.ph3.mt1.mr1[
![](img/map_for_loops.png)
]]

---

# The `purrr::map()` family of functions

.pull-left[

- Are designed to be consistent
- `map()` is the general function and close to `base::lapply()`
- `map()` introduces shortcuts (absent in `lapply()`)
- Variants to specify the type of vectorized output:
    + `map_lgl()`
    + `map_int()`
    + `map_dbl()`
    + `map_chr()`
    + `map_dfr()` data.frame rows
    + `map_dfc()` data.frame cols
- .red.bold[Fail] if coercion is impossible
]

--
 
.pull-right[

```r
map_dbl(swiss, mean)
```

```
       Fertility      Agriculture      Examination        Education 
        70.14255         50.65957         16.48936         10.97872 
        Catholic Infant.Mortality 
        41.14383         19.94255 
```

```r
map_chr(swiss, mean)
```

```
       Fertility      Agriculture      Examination        Education 
     "70.142553"      "50.659574"      "16.489362"      "10.978723" 
        Catholic Infant.Mortality 
     "41.143830"      "19.942553" 
```

```r
map_int(swiss, mean)
```

```
Error: Can't coerce element 1 from a double to a integer
```

]

---
class: hide_logo

# Linear modelling example

### Palmer penguins from previous lecture

.pull-left[

```r
library(palmerpenguins)
ggplot(penguins,
       aes(x = bill_length_mm,
           y = bill_depth_mm,
           colour = species)) +
  geom_point() +
  geom_smooth(method = "lm", formula = 'y ~ x',
      # no standard error ribbon
              se = FALSE) +
  facet_grid(island ~ .) 
```

<img src="lecture07_purrr_files/figure-html/unnamed-chunk-18-1.png" width="432" />
]

.pull-right[
.huge[How to perform those 5 linear model?]

.tiny[From [R for Data Science](http://r4ds.had.co.nz/iteration.html#the-map-functions)]

.footnote[`palmerpenguins` from _Horst AM, Hill AP, Gorman KB (2020)_]
]

---

# Reminder: fit a linear model

- Using the `pinguins` dataset we can fit a linear model to explain the `bill depth` by the `bill length` using:

.pull-left[

```r
lm(bill_depth_mm ~ bill_length_mm, data = penguins)
```

```

Call:
lm(formula = bill_depth_mm ~ bill_length_mm, data = penguins)

Coefficients:
   (Intercept)  bill_length_mm  
      20.88547        -0.08502  
```
]

.pull-right[
![](img/plot_culmen_depth.png)
]

---

# Reminder: `lm` outputs complex objects

.left-column[
#### Summarise a linear model with `base::summary()`

- `$r^2$` is low (`0.05525`) because we mix .bold[all] individuals.
- We need .bold[one] tibble .bold.large[per] group
]

.right-column[

```r
summary(lm(bill_depth_mm ~ bill_length_mm, data = penguins))
```

```

Call:
lm(formula = bill_depth_mm ~ bill_length_mm, data = penguins)

Residuals:
    Min      1Q  Median      3Q     Max 
-4.1381 -1.4263  0.0164  1.3841  4.5255

Coefficients:
               Estimate Std. Error t value Pr(>|t|)    
(Intercept)    20.88547    0.84388  24.749  < 2e-16 ***
bill_length_mm -0.08502    0.01907  -4.459 1.12e-05 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 1.922 on 340 degrees of freedom
  (2 observations deleted due to missingness)
Multiple R-squared:  0.05525,	Adjusted R-squared:  0.05247 
F-statistic: 19.88 on 1 and 340 DF,  p-value: 1.12e-05
```
]

---

# Split the penguin data

.pull-left[

```r
# split a data.frame by group, returns a list
split_peng <- group_split(palmerpenguins::penguins, 
                          island, 
                          species)
# dimensions of each tibble
# returns a list
map(split_peng, dim)
# How many observations per group?
# coerce to a double
map_dbl(split_peng, nrow)
```
]

.pull-right[

```
[[1]]
[1] 44  8

[[2]]
[1] 124   8

[[3]]
[1] 56  8

[[4]]
[1] 68  8

[[5]]
[1] 52  8
```

```
[1]  44 124  56  68  52
```

]

.center.Large[Coercion from a list to a numeric vector is required by the user.]

---

# Map the linear model

- `map(YOUR_LIST, YOUR_FUNCTION)`
- `YOUR_LIST` = `spl_mtcars`
- `YOUR_FUNCTION` can be an anonymous function (declared on the fly)

.pull-left[

```r
map(split_peng, function(x) {
  lm(bill_depth_mm ~ bill_length_mm, 
     data = x)
})
```
.large[
Curly braces can be used for:

- Several code lines
- Wrap lines to improve readability
]
]

.pull-right[

```
[[1]]