String manipulation

class: title-slide,center

<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>

# String manipulation

## Reproducible data munging

<img src="https://raw.githubusercontent.com/tidyverse/stringr/master/man/figures/logo.png" width="100px"/>]

### Roland Krause | rworkshop | 2021-09-08

---

# Session set-up

.pull-left[

.w-100.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.large[.gbox[Learning objectives]]

.float-img[<svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:50px;width:50px;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M352 96c0-53.02-42.98-96-96-96s-96 42.98-96 96 42.98 96 96 96 96-42.98 96-96zM233.59 241.1c-59.33-36.32-155.43-46.3-203.79-49.05C13.55 191.13 0 203.51 0 219.14v222.8c0 14.33 11.59 26.28 26.49 27.05 43.66 2.29 131.99 10.68 193.04 41.43 9.37 4.72 20.48-1.71 20.48-11.87V252.56c-.01-4.67-2.32-8.95-6.42-11.46zm248.61-49.05c-48.35 2.74-144.46 12.73-203.78 49.05-4.1 2.51-6.41 6.96-6.41 11.63v245.79c0 10.19 11.14 16.63 20.54 11.9 61.04-30.72 149.32-39.11 192.97-41.4 14.9-.78 26.49-12.73 26.49-27.06V219.14c-.01-15.63-13.56-28.01-29.81-27.09z"/></svg> ]

* Perform pattern matching and string manipulation
 * Print text nicely and well-formatted
]

.w-100.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.large[.ybox[`stringr` package]]
<img src="https://raw.githubusercontent.com/tidyverse/stringr/master/man/figures/logo.png" style="float:right;height:80px;"/>
 
 * Simplifies and unifies string operations in base R
 * Detection, extraction, counting, subsetting
 * Gentle [`stringr` introduction](http://stringr.tidyverse.org)
 * Different matching engines, e.g. locale-sensitive
]]

.pull-right[
.w-100.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.large[.gbox[Regular expressions]]
.float-img[<svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:50px;width:50px;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M160 320h12v16c0 8.84 7.16 16 16 16h40c8.84 0 16-7.16 16-16v-16h12c17.67 0 32-14.33 32-32V64c0-17.67-14.33-32-32-32V16c0-8.84-7.16-16-16-16h-64c-8.84 0-16 7.16-16 16v16c-17.67 0-32 14.33-32 32v224c0 17.67 14.33 32 32 32zm304 128h-1.29C493.24 413.99 512 369.2 512 320c0-105.88-86.12-192-192-192v64c70.58 0 128 57.42 128 128s-57.42 128-128 128H48c-26.51 0-48 21.49-48 48 0 8.84 7.16 16 16 16h480c8.84 0 16-7.16 16-16 0-26.51-21.49-48-48-48zm-360-32h208c4.42 0 8-3.58 8-8v-16c0-4.42-3.58-8-8-8H104c-4.42 0-8 3.58-8 8v16c0 4.42 3.58 8 8 8z"/></svg> ]

* Matching and substituting of strings 
 * "^lecture([0-9]{1,2}).*[^_].Rmd$/\1.Rmd/g"
 * See [R for data science](http://r4ds.had.co.nz/strings.html#matching-patterns-with-regular-expressions)

]

.w-100.bg-washed-blue.b--blue.ba.bw2.br3.pb2.shadow-5.ph3.mt3.mr1[
.ybox[`glue` package]
<img src="https://raw.githubusercontent.com/tidyverse/glue/master/man/figures/logo.png" style="float:right;height:80px;"/>
 * Join and output complex strings
 * Concise [`glue` introduction](http://glue.tidyverse.org)
]
]
---
# String examples in Base R

--
.pull-left[
.bbox[Strings are character objects]

```r
# A character object = colloquially called "string"
my_string <- "cat"

my_string
```

```
[1] "cat"
```

```r
my_other_string <- 'catastrophe' # single quotes

not_so_numeric <- as.character(3.1415)

not_so_numeric
```

```
[1] "3.1415"
```

```r
# A character vector

my_string_vec <- c("atg", "ttg", "tga")
```

]
.pull-right[
.bbox[Printing complex objects] 
#### C style with placeholder

```r
sprintf("Hello %s, how is day %d of this course?", 
        "John Doe", 12)
```

```
[1] "Hello John Doe, how is day 12 of this course?"
```
]

---
# Comparisons of Base R and `stringr`

```r
pattern <- "r"
my_words <- c( "cat", "cart","carrot", "catastrophe",
         "dog","rat",  "bet")
```

.pull-left[
### Base R

```r
grep(pattern, my_words)
```

```
[1] 2 3 4 6
```

```r
grep(pattern, my_words, value = TRUE)
```

```
[1] "cart"        "carrot"      "catastrophe" "rat"        
```

```r
substr(my_words, 1, 3)
```

```
[1] "cat" "car" "car" "cat" "dog" "rat" "bet"
```

```r
gsub(pattern, "R", my_words)
```

```
[1] "cat"         "caRt"        "caRRot"      "catastRophe" "dog"        
[6] "Rat"         "bet"        
```
]
--
.pull-right[
### `stringr`

```r
library(stringr)

str_which(my_words, pattern)
```

```
[1] 2 3 4 6
```

```r
str_subset(my_words, pattern)
```

```
[1] "cart"        "carrot"      "catastrophe" "rat"        
```

```r
str_sub(my_words, 1, 2)
```

```
[1] "ca" "ca" "ca" "ca" "do" "ra" "be"
```

```r
str_replace(my_words, pattern, "R")
```

```
[1] "cat"         "caRt"        "caRrot"      "catastRophe" "dog"        
[6] "Rat"         "bet"        
```
]

---
# Why use `stringr`?

.pull-left[
.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.large[.gbox[Motivation]]
<img src="https://raw.githubusercontent.com/tidyverse/stringr/master/man/figures/logo.png" style="float:right;height:80px;"/>

* Consistency
* Less typing and looking up things

.bbox[Usage]

* All functions in stringr start with `str_` 
* All take a vector of strings as the first argument 
  + ("data first")
  + `>%>` now works
* All functions properly vectorised

]]

.pull-right[

.flex[
.w-70.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.bbox[Useful additions]

Viewing matches rendered in HTML
<style type="text/css">
.box .html-widget {
  width: 100% !important;
  padding: 10px;
  margin: 10px;
  background-color: white;
  color: black;
  
}

.str_view .match {
  border: 2px solid orange;
  background-color: yellow;
}
</style>

```r
str_view_all(my_words, pattern)
```

<div id="htmlwidget-89c8f7f7ee20cd565a10" style="width:960px;height:100%;" class="str_view html-widget"></div>
<script type="application/json" data-for="htmlwidget-89c8f7f7ee20cd565a10">{"x":{"html":"<ul>\n  <li>cat<\/li>\n  <li>ca<span class='match'>r<\/span>t<\/li>\n  <li>ca<span class='match'>r<\/span><span class='match'>r<\/span>ot<\/li>\n  <li>catast<span class='match'>r<\/span>ophe<\/li>\n  <li>dog<\/li>\n  <li><span class='match'>r<\/span>at<\/li>\n  <li>bet<\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>
]]]
---
class: nvs3
# `stringr` overview
<img src="img/stringr_overview.png" style="float:center;height:600px;"/>

---

class: nvs3, inverse
<img src="img/stringr_cheatsheet-1.png" style="float:center;height:600px;"/>

---
class: nvs3, inverse

---
# Length
.pull-left[.w-100.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph4[
.large[.bbox[Length of items in character vector]]

```r
str_length(my_words)
```

```
[1]  3  4  6 11  3  3  3
```
]]
--
.pull-right[
.w-100.bg-washed-red.b--red.ba.bw2.br3.shadow-5.ph3.mr1[
.large[.rbox[Warning]]

```r
length(my_words)
```

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

---
# Elements of strings 
.pull-left[
### Substrings

```r
my_words
```

```
[1] "cat"         "cart"        "carrot"      "catastrophe" "dog"        
[6] "rat"         "bet"        
```

```r
str_sub(my_words, 1, 4)
```

```
[1] "cat"  "cart" "carr" "cata" "dog"  "rat"  "bet" 
```

### Replace <svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:1em;width:1em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M0 168v-16c0-13.255 10.745-24 24-24h360V80c0-21.367 25.899-32.042 40.971-16.971l80 80c9.372 9.373 9.372 24.569 0 33.941l-80 80C409.956 271.982 384 261.456 384 240v-48H24c-13.255 0-24-10.745-24-24zm488 152H128v-48c0-21.314-25.862-32.08-40.971-16.971l-80 80c-9.372 9.373-9.372 24.569 0 33.941l80 80C102.057 463.997 128 453.437 128 432v-48h360c13.255 0 24-10.745 24-24v-16c0-13.255-10.745-24-24-24z"/></svg>

```r
str_replace(my_words, "a", "A")
```

```
[1] "cAt"         "cArt"        "cArrot"      "cAtastrophe" "dog"        
[6] "rAt"         "bet"        
```

]
--

.pull-right[

### Spliting strings

```r
str_split(my_words, "a")
```

```
[[1]]
[1] "c" "t"

[[2]]
[1] "c"  "rt"

[[3]]
[1] "c"    "rrot"

[[4]]
[1] "c"       "t"       "strophe"

[[5]]
[1] "dog"

[[6]]
[1] "r" "t"

[[7]]
[1] "bet"
```

]

---
# Matching strings
.pull-left[

### Detect matching strings   <svg aria-hidden="true" role="img" viewBox="0 0 576 512" style="height:1em;width:1.12em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M574.1 280.37L528.75 98.66c-5.91-23.7-21.59-44.05-43-55.81-21.44-11.73-46.97-14.11-70.19-6.33l-15.25 5.08c-8.39 2.79-12.92 11.86-10.12 20.24l5.06 15.18c2.79 8.38 11.85 12.91 20.23 10.12l13.18-4.39c10.87-3.62 23-3.57 33.16 1.73 10.29 5.37 17.57 14.56 20.37 25.82l38.46 153.82c-22.19-6.81-49.79-12.46-81.2-12.46-34.77 0-73.98 7.02-114.85 26.74h-73.18c-40.87-19.74-80.08-26.75-114.86-26.75-31.42 0-59.02 5.65-81.21 12.46l38.46-153.83c2.79-11.25 10.09-20.45 20.38-25.81 10.16-5.3 22.28-5.35 33.15-1.73l13.17 4.39c8.38 2.79 17.44-1.74 20.23-10.12l5.06-15.18c2.8-8.38-1.73-17.45-10.12-20.24l-15.25-5.08c-23.22-7.78-48.75-5.41-70.19 6.33-21.41 11.77-37.09 32.11-43 55.8L1.9 280.37A64.218 64.218 0 0 0 0 295.86v70.25C0 429.01 51.58 480 115.2 480h37.12c60.28 0 110.37-45.94 114.88-105.37l2.93-38.63h35.75l2.93 38.63C313.31 434.06 363.4 480 423.68 480h37.12c63.62 0 115.2-50.99 115.2-113.88v-70.25c0-5.23-.64-10.43-1.9-15.5zm-370.72 89.42c-1.97 25.91-24.4 46.21-51.06 46.21H115.2C86.97 416 64 393.62 64 366.11v-37.54c18.12-6.49 43.42-12.92 72.58-12.92 23.86 0 47.26 4.33 69.93 12.92l-3.13 41.22zM512 366.12c0 27.51-22.97 49.88-51.2 49.88h-37.12c-26.67 0-49.1-20.3-51.06-46.21l-3.13-41.22c22.67-8.59 46.08-12.92 69.95-12.92 29.12 0 54.43 6.44 72.55 12.93v37.54z"/></svg>

```r
str_detect(my_words, "o")
```

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

### Retrieving (only) matching strings

```r
str_subset(my_words, "r")
```

```
[1] "cart"        "carrot"      "catastrophe" "rat"        
```

.w-100.bg-washed-red.b--red.ba.bw2.br3.shadow-5.ph3.mr1[

Useful interactively primarily.
Dangerous in programming!
]
]
--
.pull-right[

### Retrieving matching strings

```r
str_match(my_words, "a")
```

```
     [,1]
[1,] "a" 
[2,] "a" 
[3,] "a" 
[4,] "a" 
[5,] NA  
[6,] "a" 
[7,] NA  
```
Includes capture groups (see regular expressions)

### Extracting matches

```r
str_extract(my_words, "a")
```

```
[1] "a" "a" "a" "a" NA  "a" NA 
```
]

---
# Better treatment of conversion

```r
my_col <- c("F", "M", "female", "male", "male", "female", "female", "männlich")

convert_gender <- function(x){
  case_when(
    str_detect(x, "^[Ff]") ~ "Female", 
    str_detect(x, "^[Mm]") ~ "Male",
    TRUE ~ x
  )
}

convert_gender(my_col)
```

```
[1] "Female" "Male"   "Female" "Male"   "Male"   "Female" "Female" "Male"  
```

---
class: middle, center, inverse
# Regular expressions

---

# Getting started with regular expressions

.pull-left[
.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.large[.gbox[Higher aims]]  
 * Extract particular characters, e.g. numbers only
 * Express a variety of character following or preceding patterns
 * Matching any character
 * Not matching a particular character
]
]
--
.pull-right[

.bg-washed-blue.b--blue.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.large[.bbox[Prerequisites complex matching]]

* Regular expressions look like strings but are converted to a particular expression object.
* Can be done explicitly by `regex()` -- rarely necessary
* `print()` is giving the quoted strings and therefore misleading
* Use `cat()` or `writeLines()` to see strings properly escaped.
+ `writeLines()` preferred for writing
]]

---
# Flexible matching though *metacharacters*

.pull-left[
.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mr1.large[
.bbox[Metacharacters ]
 **Symbols matching a variety of characters as opposed to literal matches.**
]

.bg-washed-blue.b--blue.ba.bw2.br3.shadow-5.ph3.mt1.mr1[
*  *.* (dot) represents any character
* Exception is the newline character (`\n`)

```r
str_view(my_words, ".at")
```

<div id="htmlwidget-57105de42ced0a31a9af" style="width:960px;height:100%;" class="str_view html-widget"></div>
<script type="application/json" data-for="htmlwidget-57105de42ced0a31a9af">{"x":{"html":"<ul>\n  <li><span class='match'>cat<\/span><\/li>\n  <li>cart<\/li>\n  <li>carrot<\/li>\n  <li><span class='match'>cat<\/span>astrophe<\/li>\n  <li>dog<\/li>\n  <li><span class='match'>rat<\/span><\/li>\n  <li>bet<\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

]
]
--
.pull-right[
.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt1.mr1[

* `.` matches exactly one occurrence

```r
 str_subset(my_words, "c.t")
```

```
[1] "cat"         "catastrophe"
```

* `+` (plus) represents one or more occurrences

```r
str_subset(my_words, 'c.r+')
```

```
[1] "cart"   "carrot"
```

* `*` (star) represents zero or more occurrences

```r
str_subset(my_words, 'c.r*')
```

```
[1] "cat"         "cart"        "carrot"      "catastrophe"
```
]]

---

# Grouping 
.pull-left[

.bg-washed-blue.b--blue.ba.bw2.br3.shadow-5.ph3.mt1.mr1[
.box[#### Group terms with parentheses `(` and `)`]

```r
str_view(my_words, 'c(.r)+t')
```

<div id="htmlwidget-b2e82c79f92d7086d779" style="width:960px;height:100%;" class="str_view html-widget"></div>
<script type="application/json" data-for="htmlwidget-b2e82c79f92d7086d779">{"x":{"html":"<ul>\n  <li>cat<\/li>\n  <li><span class='match'>cart<\/span><\/li>\n  <li>carrot<\/li>\n  <li>catastrophe<\/li>\n  <li>dog<\/li>\n  <li>rat<\/li>\n  <li>bet<\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

]]
--
.pull-right[

.bg-washed-blue.b--blue.ba.bw2.br3.shadow-5.ph3.mt1.mr1[
.box[#### Capture groups with `str_match()`]

```{r"}
str_match(my_words, 'c(.r)*t')
```

]]
---
### Alternation operator `|` ( logical OR )

```r
str_subset(my_words, '(c.t)|(c.rt)')
```

```
[1] "cat"         "cart"        "catastrophe"
```

---
# Quantifying a number of matches 
.pull-left[
.w-70.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.bbox[The preceding item will be matched ...]

* `?`  at most once.
 * `*`  matched zero or more times.
 * `+`  one or more times.
 * `{n}`  exactly 'n' times.
 * `{n,}` 'n' or more times.
 * `{n,m}`  at least 'n' times, but not more than 'm' times.
]]

.pull-right[

```r
dna <- "ATGGTAACCGGTAGGTAGTAAAGGTCCC"
str_view_all(dna, "AA?")
```

<div id="htmlwidget-35a83b03ec594caedd18" style="width:960px;height:100%;" class="str_view html-widget"></div>
<script type="application/json" data-for="htmlwidget-35a83b03ec594caedd18">{"x":{"html":"<ul>\n  <li><span class='match'>A<\/span>TGGT<span class='match'>AA<\/span>CCGGT<span class='match'>A<\/span>GGT<span class='match'>A<\/span>GT<span class='match'>AA<\/span><span class='match'>A<\/span>GGTCCC<\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

```r
str_view_all(dna, "AA+")
```

<div id="htmlwidget-8cec4d4122a64992261b" style="width:960px;height:100%;" class="str_view html-widget"></div>
<script type="application/json" data-for="htmlwidget-8cec4d4122a64992261b">{"x":{"html":"<ul>\n  <li>ATGGT<span class='match'>AA<\/span>CCGGTAGGTAGT<span class='match'>AAA<\/span>GGTCCC<\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

```r
str_view_all(dna, "A{3,}")
```

<div id="htmlwidget-53383d5e7bde141afaca" style="width:960px;height:100%;" class="str_view html-widget"></div>
<script type="application/json" data-for="htmlwidget-53383d5e7bde141afaca">{"x":{"html":"<ul>\n  <li>ATGGTAACCGGTAGGTAGT<span class='match'>AAA<\/span>GGTCCC<\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

]
---
# *Greedy* and *lazy* matching

.pull-left[
.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3[
.bbox[Matches are *greedy* by default ]

Match the longest possible subsequence.

```r
dna <- "ATGGTAACCGGTAGGTAGTAAAGGTCCC"
str_extract(dna, "AAG.{2,5}")
```

```
[1] "AAGGTCCC"
```

```r
str_extract(dna, "ATG.+C")
```

```
[1] "ATGGTAACCGGTAGGTAGTAAAGGTCCC"
```
]]
--
.pull-right[
.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3[
.bbox[*Lazy* matching]

Adding `?` to a regular expression makes it *lazy*, and returns the shortest possible match.

```r
str_extract(dna, "AAG.{2,5}?")
```

```
[1] "AAGGT"
```

```r
str_extract(dna, "ATG.+?C")
```

```
[1] "ATGGTAAC"
```
]]
---
# Anchors

.pull-left[

#  `^` Start of string

```r
my_words
```

```
[1] "cat"         "cart"        "carrot"      "catastrophe" "dog"        
[6] "rat"         "bet"        
```

```r
str_subset(my_words , '^c')
```

```
[1] "cat"         "cart"        "carrot"      "catastrophe"
```
]
--
.pull-right[

# `$` End of string

```r
str_subset(my_words, 'r.$')
```

```
[1] "cart"
```
]

---
# Character classes 
 
.pull-left[
### Special characters 
.fl[
|Pattern | Matches    | Complement | Matches      |
|:------:|------------|:----------:|---------------|
|`\d`    | Digit      | `\D`       | No digit    |
|`\s`    | Whitespace | `\S`       | No whitespace|
|`\w`    | Word chars | `\W`       | No work char|
|`\b`    | Boundaries | `\B`       | Within words|
|`\p{}`  | Property   | `\P{}`    | Not that property|
]]

.pull-right[

### Example for Unicode properties

.left.fl[
| Code | Description |
|-----:|-------------|
|Ll   | Lowercase letter |
|Lu   | Uppercase letter |
|Sc   | A currency sign |
|Sm   | Symbol of mathematical use|
| ... | See [documentation](http://www.unicode.org/reports/tr44/#Property_Index)|

Powerful but complex to use.
]]
---
# Examples 
.pull-left[
.gbox[Matching digits]

```r
str_extract(my_words, "\\d+")
```

```
[1] NA NA NA NA NA NA NA
```

.bbox[Counting word elements]

```r
str_count(my_words, "\\w+")
```

```
[1] 1 1 1 1 1 1 1
```

```r
str_length(my_words)
```

```
[1]  3  4  6 11  3  3  3
```

```r
str_count(my_words, "\\w")
```

```
[1]  3  4  6 11  3  3  3
```

Counting all matches to words.

]
--
.pull-right[ 
.gbox[ Matching "everything that you want" ]

```r
str_extract(my_words, "\\S+")
```

```
[1] "cat"         "cart"        "carrot"      "catastrophe" "dog"        
[6] "rat"         "bet"        
```

.gbox[Unicode ]

```r
str_extract(my_words, "\\p{Lu}+")
```

```
[1] NA NA NA NA NA NA NA
```

]
---
# Extended list of regular expressions
.pull-left[
### Readable short cuts 
.w-70.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3[
Built-in (`stringi` - `stringr`)

Requires `perl = TRUE` flag in base R.

Works out of the box in `stringr`.
]

- **[:upper:]** Upper-case letters. 
- **[:lower:]** Lower-case letters.
- **[:alpha:]** Alphabetic characters: '[:lower:]' and '[:upper:]'.
- **[:digit:]** Digits: '0 1 2 3 4 5 6 7 8 9'.
- **[:punct:]** Punctuation characters: '! " # $ % & ' ( ) * + , - . / : ; < = > ? @ ' and others.
- **[:space:]** Space characters: tab, newline, vertical tab, form feed, carriage return, and space.
- **[:blank:]** Blank characters: space and tab.
- **[:alnum:]** Alphanumeric characters: '[:alpha:]' and '[:digit:]'.
- **[:graph:]** Graphical characters: '[:alnum:]' and '[:punct:]'.
]
--
.pull-right[

```r
my_words
```

```
[1] "cat"         "cart"        "carrot"      "catastrophe" "dog"        
[6] "rat"         "bet"        
```

```r
str_subset(my_words, "[:punct:]")
```

```
character(0)
```

```r
str_extract(my_words, "[:punct:]")
```

```
[1] NA NA NA NA NA NA NA
```
]

---
# Roll your own character class 
.flex[
.w-30.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph4.mt1[
.large[.gbox[Define groups]]

* **[a-z]** lowercase letters
 * **[a-zA-Z]** any (ascii) letter
 * **[0-9]** any number
 * **[aeiou]** any vowel
 * **[0-7ivx]** any of 0 to 7, i, v, and x
]
.w-40.bg-washed-blue.b--blue.ba.bw2.br3.shadow-5.ph4.mt1.mr1.ml1[
.bbox[Example]

```r
str_subset(c("Rpl12", "Rpn12", 
             "Rps1",
             "Pre1"), 'Rp[ls]')
```

```
[1] "Rpl12" "Rps1" 
```
]

.w-30.bg-washed-red.b--red.ba.bw2.br3.shadow-5.ph3.mt1.mr1[
.rbox[Rely on built-in groups where possible]

Note that the set of alphabetic characters includes accents such as ß, ç or ö which are very common in some languages. Use is more general than **[A-Za-z]** which ascii characters only. .float-img[<svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:1em;width:1em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:red;overflow:visible;position:relative;"><path d="M504 256c0 136.997-111.043 248-248 248S8 392.997 8 256C8 119.083 119.043 8 256 8s248 111.083 248 248zm-248 50c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z"/></svg>]

]

---

# Matching metacharacters

.pull-left[
.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.mr1[

We saw special characters such as
 
 - `.`
 - `+`
 - `*`
 - or `$`

What if we want to match them? 
]]
--
.pull-right[

.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3.mr1[

.large[.gbox[Strings containing only a full stop]]

```r
vec2 <- c("YKL045W-A", "12+45=57", "$1200.00", "ID2.2")

str_subset(vec2 , '.')
```

```
[1] "YKL045W-A" "12+45=57"  "$1200.00"  "ID2.2"    
```
Not what we wanted.
]
]

---
# Excursion

.pull-left[
.bg-washed-red.b--red.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.rbox[Implicit conversion]
R wraps regular expressions as strings without explicit interference of the user.
When converting from *string* to *regular expression* internally, single backslashes (`\`) are already converted. .right[<svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:48px;width:48px;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:red;overflow:visible;position:relative;"><path d="M504 256c0 136.997-111.043 248-248 248S8 392.997 8 256C8 119.083 119.043 8 256 8s248 111.083 248 248zm-248 50c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z"/></svg>]

]
.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.bbox[Solution]
.mt1[<svg aria-hidden="true" role="img" viewBox="0 0 352 512" style="height:24px;width:16.5px;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M96.06 454.35c.01 6.29 1.87 12.45 5.36 17.69l17.09 25.69a31.99 31.99 0 0 0 26.64 14.28h61.71a31.99 31.99 0 0 0 26.64-14.28l17.09-25.69a31.989 31.989 0 0 0 5.36-17.69l.04-38.35H96.01l.05 38.35zM0 176c0 44.37 16.45 84.85 43.56 115.78 16.52 18.85 42.36 58.23 52.21 91.45.04.26.07.52.11.78h160.24c.04-.26.07-.51.11-.78 9.85-33.22 35.69-72.6 52.21-91.45C335.55 260.85 352 220.37 352 176 352 78.61 272.91-.3 175.45 0 73.44.31 0 82.97 0 176zm176-80c-44.11 0-80 35.89-80 80 0 8.84-7.16 16-16 16s-16-7.16-16-16c0-61.76 50.24-112 112-112 8.84 0 16 7.16 16 16s-7.16 16-16 16z"/></svg> Need to escape `\` with an additional one `-> \\`.

]
]
]

--
.pull-right[

### Double escape

```r
str_subset(vec2, '\.')
```

```
Error: '\.' is an unrecognized escape in character string starting "'\."
```

```r
str_subset(vec2, '\\.')
```

```
[1] "$1200.00" "ID2.2"   
```

]

---
# No escape 
.pull-left[
.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3.mr1[

To match a `\`, our pattern must represent `\\`.

How to match `c("a\\backslash", "nobackslash", "slash","\n")`?

Note the difference when printing meta-characters.

]

```r
slash_vec <- c("a\\backslash", "nobackslash", "slash","\n")
print(slash_vec)
```

```
[1] "a\\backslash" "nobackslash"  "slash"        "\n"          
```

```r
cat(slash_vec)
```

```
a\backslash nobackslash slash 
```

```r
str_subset(slash_vec, '\\') 
```

```
Error in stri_subset_regex(string, pattern, omit_na = TRUE, negate = negate, : Unrecognized backslash escape sequence in pattern. (U_REGEX_BAD_ESCAPE_SEQUENCE, context=`\`)
```
]

.pull-right[

### Use more backslashes!!!

Our string must contain 4 backslashes!

```r
str_subset(slash_vec, '\\\\')
```

```
[1] "a\\backslash"
```
]
---
# Search and replace
.pull-left[

### `str_replace()`

```r
mirna <-
  c("dme-bantam",
    "dme-let-7",
    "dme-mir-1",
    "dme-mir-2a-1",
    "mmu-let-7f-2")
str_replace(mirna, '-', '|')
```

Only the first match is replaced!
]
--
.pull-right[
### `str_replace_all()`

```r
str_replace_all(mirna, '-', '|')
```

```
[1] "dme|bantam"   "dme|let|7"    "dme|mir|1"    "dme|mir|2a|1" "mmu|let|7f|2"
```

]

---
# Backreferences

### Group matches

`\1`, `\2` and so forth refer to groups matched with `()`.

# Constructing new strings from regular expression matches

```r
uniprot <- c("Q6QU88_CALBL", "CO1A2_HUMAN", "SAMH1_HUMAN", "NPRL2_DROME")
str_replace(uniprot, '(\\S+)_(\\S+)', "\\2: \\1")
```

```
[1] "CALBL: Q6QU88" "HUMAN: CO1A2"  "HUMAN: SAMH1"  "DROME: NPRL2" 
```

---
# Helpers

.pull-left[
### `regexplain`

Simple [addin for RStudio](https://github.com/gadenbuie/regexplain) by [Garrick Aden-Buie](https://github.com/gadenbuie/)

* Test regular expressions on the fly
 * Reference library
 * Cheatsheet
 * test it [live](https://www.garrickadenbuie.com/project/regexplain/)

```r
devtools::install_github("gadenbuie/regexplain")

regexplain::regexplain_gadget()
```
 
]

.pull-right[

![](img/tidy_regexplain.png)
]
---

# Constructing strings with `glue` and `stringr`

.w-70.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt3.ml5[
.large[.ybox[`glue` is not load with `library(tidyverse)`]]

```r
library(glue)
```

```

Attaching package: 'glue'
```

```
The following object is masked from 'package:dplyr':

collapse
```
]

---
# Joining strings
.w-100.bg-washed-yellow.b--gold.ba.bw2.br3.shadow-5.ph3.mt3.mr1[
.ybox[Base R and `glue` ]

Several ways to join strings even in the tidyverse.

This is the `stringr` way, options are used in other
packages too, e.g. `paste()`. 
]

.pull-left[
### Concatenation

```r
str_c(my_words, collapse = "|")
```

```
[1] "cat|cart|carrot|catastrophe|dog|rat|bet"
```
### Vectorization of concatenation

```r
str_c(my_words, my_words, sep = ": ")
```

```
[1] "cat: cat"                 "cart: cart"              
[3] "carrot: carrot"           "catastrophe: catastrophe"
[5] "dog: dog"                 "rat: rat"                
[7] "bet: bet"                
```
]

--
.pull-right[
### Padding

```r
str_pad(my_words, 12)
```

```
[1] "         cat" "        cart" "      carrot" " catastrophe" "         dog"
[6] "         rat" "         bet"
```
### Trimming

```r
str_trunc(c("anachronism", "antebellum", "antithesis"), 6)
```

```
[1] "ana..." "ant..." "ant..."
```
]
---

# Examples

### Functions of `glue` 
* Format complex character objects will an easy syntax
* Concatenate strings useful white space treatment
* Made to work with `%>%`

```r
year_pub <- 1881
book <- "The Formation of Vegetable Mould through the Action of Worms"
author <- "Charles Darwin"

glue("The author {author}",
     ' also wrote "{book}"', # note the use of single quote to escape double quotes
      " in {year_pub}.")
```

```
The author Charles Darwin also wrote "The Formation of Vegetable Mould through the Action of Worms" in 1881.
```

---
class: hide_logo
# Collapsing

```r
glue::glue_collapse(letters, '&')
```

```
a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z
```

# Vectorised operation utilizing pipes, `glue_data()`

```r
head(patient)
```

```
# A tibble: 6 × 2
  subject_id gender_age
       <int> <chr>     
1       1001 m-34      
2       1002 f-24      
3       1003 m-53      
4       1004 f-44      
5       1005 m-24      
6       1006 f-30      
```

```r
# with pipes and non-standard evaluation
sample_n( patient, 5) %>%
  separate(gender_age, into=c("gender", "age")) %>% 
  glue_data("This case is {age} years old and reports gender as '{gender}'. ")
```

```
This case is 30 years old and reports gender as 'f'. 
This case is 53 years old and reports gender as 'm'. 
This case is 34 years old and reports gender as 'm'. 
This case is 44 years old and reports gender as 'f'. 
This case is 24 years old and reports gender as 'f'. 
```

---

## Before we stop

.flex[
.w-50.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt2.ml1[
.large[.gbox[Resources]

* `stringi` -- General implementation of regular expressions
 * `stringr` -- Wrapper for vectorisation and convenience functions
 * `glue` -- formating complex strings
]]
.w-50.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt2.ml2[
.large[.bbox[Acknowledgments  🙏 👏]]

- Charlotte Wickham 
 - Hadley Wickham 
 - Marek Gagolewski (Author of `stringi` implementation)
]]
.flex[
.w-50.bg-washed-green.b--green.ba.bw2.br3.shadow-5.ph3.mt2.ml1[
.large[.ybox[Further reading <svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M448 360V24c0-13.3-10.7-24-24-24H96C43 0 0 43 0 96v320c0 53 43 96 96 96h328c13.3 0 24-10.7 24-24v-16c0-7.5-3.5-14.3-8.9-18.7-4.2-15.4-4.2-59.3 0-74.7 5.4-4.3 8.9-11.1 8.9-18.6zM128 134c0-3.3 2.7-6 6-6h212c3.3 0 6 2.7 6 6v20c0 3.3-2.7 6-6 6H134c-3.3 0-6-2.7-6-6v-20zm0 64c0-3.3 2.7-6 6-6h212c3.3 0 6 2.7 6 6v20c0 3.3-2.7 6-6 6H134c-3.3 0-6-2.7-6-6v-20zm253.4 250H96c-17.7 0-32-14.3-32-32 0-17.6 14.4-32 32-32h285.4c-1.9 17.1-1.9 46.9 0 64z"/></svg>]]

* [Strings in R for Data Science](http://r4ds.had.co.nz/strings.html)

]
.w-50.pv2.ph3.mt2.ml1[
.huge[.bbox[Thank you for your attention!]]
]
]
---

# Try it all yourself!

- Select the practical "String manipulation" for this lecture.