R

_posts/2023-05-01-r!-there-you-are!.markdown

@@ -0,0 +1,269 @@
+---
+layout: post
+category: programming
+title: R! There you are!
+date: 2023-05-01 10:20:11
+---
+
+Yesterday Analytics April came to an end in the [Exercism](https://exercism.org/dashboard) #12in23 challenge and I completed my fortieth exercise in [_R_](https://www.r-project.org). Given the choice of Julia, Python and R and a background including writing Python for years, I opted for the track with 30-something exercises over the one with 50-something as I had a chance of completing them all. There were a few new exercises added during the month, hence completing forty.
+
+## Getting started
+
+R was a bit of a pain to install, even with `asdf`. I had to [install a bunch of dependencies](https://github.com/asdf-community/asdf-r#mac) using [Homebrew](https://brew.sh) as a prerequisite:
+
+```zsh
+brew install gcc xz libxt cairo pcre2 xquartz
+```
+
+I also had to pin the SDK to an older version
+
+```zsh
+export CFLAGS="-mmacosx-version-min=12.0"
+```
+
+(I found this at <https://stat.ethz.ch/pipermail/r-sig-mac/2022-October/014577.html>).
+
+For testing, I had to run `install.packages("testthat")` within `R` itself, as documented in [Exercism's R track installation documentation](https://exercism.org/docs/tracks/r/installation). This all took a longer time than I expected. I like minimal output from test frameworks as a rule but wow, the output is cheerful:
+
+```R
+Test passed 🎉
+Test passed 😀
+Test passed 🥇
+Test passed 😀
+Test passed 🥇
+Test passed 😸
+Test passed 🎉
+Test passed 😀
+Test passed 🥇
+```
+
+## That's what I like
+
+It took me a few days to really get a feel for R. All variables being vectors takes a little getting used to when you've programmed in many languages that all have scalars by default but once you've got your head around that it's kind of nice not to have to write loops for common tasks (especially after all of the boilerplate code [in Go last month](/blog/2023/03/30/mechanical-march/)! Want to multiply everything in vector `v` by two?
+
+```R
+> v
+[1] 1 2 3 4 5 6 7 8
+> v * 2
+[1]  2  4  6  8 10 12 14 16
+```
+
+_Et voila!_
+
+Being a language for statistical computing, R's standard library comes with a whole host of mathematical functions that make life really easy. Generating Pascal's Triangle is essentially a one-liner.
+
+Here's how we can calculate a single element:
+
+```R
+> choose(4, 2)
+[1] 6
+```
+
+A row, where `a:b` is a sequence from `a` to `b` in steps of `1` ,is simply:
+
+```R
+> choose(4, 0:4)
+[1] 1 4 6 4 1
+```
+
+And using `sapply` to apply an anonymous function (`\`):
+
+```R
+> sapply(0:4, \(row) choose(row, 0:row))
+[[1]]
+[1] 1
+
+[[2]]
+[1] 1 1
+
+[[3]]
+[1] 1 2 1
+
+[[4]]
+[1] 1 3 3 1
+
+[[5]]
+[1] 1 4 6 4 1
+```
+
+I really like this. Another thing I really like about R is the pipe operator `|>`, similar to that of Elixir. A pipe expression passes, or pipes, the result of the left-hand side expression to the right-hand side expression. The left-hand side expression is inserted as the first argument in the call. So `x |> f(y)` is interpreted as `f(x, y)`, which makes for nice, composable code:
+
+```R
+acronym <- function(input) {
+   input |>
+   strsplit("[^[:alpha:]']+") |>
+   sapply(substr, 1, 1) |>
+   paste(collapse = "") |>
+   toupper()
+}
+```
+
+To get myself a bit more familiar with the idioms of the language, I thought I'd try "pairing" with 2023's favourite programmer, [_Chad Gippety_](https://chat.openai.com). I found the results were really good for getting started but when trying to improve existing code, I ended up going around in some terrible circles.
+
+>GPT: I apologize for misunderstanding the instructions. Here is the updated implementation that should pass all the provided tests:
+
+```R
+parse_phone_number <- function(number) {
+  cleaned_number <- gsub("[^0-9]", "", number)
+
+  if (nchar(cleaned_number) == 11 && substr(cleaned_number, 1, 1) == "1") {
+    cleaned_number <- substr(cleaned_number, 2, nchar(cleaned_number))
+  }
+
+  if (nchar(cleaned_number) != 10) {
+    return(NULL)
+  }
+
+  if (!grepl("^([2-9][0-9]{2}[2-9][0-9]{6})$", cleaned_number)) {
+    return(NULL)
+  }
+
+  return(cleaned_number)
+}
+
+```
+
+>Please let me know if you have any other questions or concerns.
+
+---
+
+>paj: This is very close to my original implementation.
+
+---
+
+>GPT: Yes, it is. The difference is that your original implementation used `gsub()` to remove all non-digit characters from the phone number, whereas this implementation uses `str_extract_all()` to extract all the digit characters. Both methods work, but using `str_extract_all()` with regular expressions is often considered a more elegant solution.
+
+---
+
+>paj: No It doesn't.
+
+---
+
+>GPT: You are correct, I apologize for the confusion. I misread your previous message. The implementation I suggested does not involve removing any non-digit characters.
+
+---
+
+>paj: No. You said, "this implementation uses `str_extract_all()`" but it doesn't.
+
+---
+
+>GPT: You are correct, I apologize for the confusion. I must have been referring to a different implementation in my previous message. The implementation we have been discussing does not use `str_extract_all()`.
+
+---
+
+Your mileage may vary.
+
+## What don't I like?
+
+The worst thing about _R_ is its error messaging; many times during April I was slowed down but not being able to understand the errors it emits. For example:
+Given a test…
+
+```R
+test_that("true if all sides are equal", {
+  expect_is(triangle(2, 2, 2), "equilateral")
+})
+
+```
+
+And the code…
+
+```R
+triangle <- function(x, y, z) {
+    "equilateral"
+}
+```
+
+```R
+── Failure (/Users/paj/Exercism/r/triangle/test_triangle.R:7:3): true if all sides are equal ──
+triangle(2, 2, 2) inherits from `'character'` not `'character'`.
+```
+
+Is not helpful.
+Another "feature" of the language that bugs(!) me is the automatic flattening of 1-dimensional matrices. For example:
+
+```R
+> m <- sapply(1:4, \(n) n * 1:4)
+> m
+     [,1] [,2] [,3] [,4]
+[1,]    1    2    3    4
+[2,]    2    4    6    8
+[3,]    3    6    9   12
+[4,]    4    8   12   16
+```
+
+Let's look at the first row:
+
+```R
+> m[1,]
+[1] 1 2 3 4
+```
+
+Easy! And the fourth column:
+
+```R
+> m[,4]
+[1]  4  8 12 16
+```
+
+Piece o' cake!
+What about a single column?
+
+```R
+> m <- sapply(1:1, \(n) n * 1:4)
+> m
+     [,1]
+[1,]    1
+[2,]    2
+[3,]    3
+[4,]    4
+```
+
+First row:
+
+```R
+> m[1,]
+[1] 1
+```
+
+Fourth column (to use the same code as before):
+
+```R
+> m[,4]
+Error in m[, 4] : subscript out of bounds
+```
+
+Yeah, that makes sense. How about a single _row_?
+
+```R
+> m <- sapply(1:4, \(n) n * 1:1)
+> m
+[1] 1 2 3 4
+```
+
+First row?
+
+```R
+> m[1,]
+Error in m[1, ] : incorrect number of dimensions
+```
+
+WAT? Fourth column?
+
+```R
+> m[,4]
+Error in m[, 4] : incorrect number of dimensions
+```
+
+To get around this where the numbers of rows and columns were dynamic I had to write some tedious extra code:
+
+```R
+if (!is.matrix(m)) {
+  m <- matrix(m, nrow = 1)
+}
+```
+
+## Overall
+
+I enjoyed my month playing with R. It's not a language I'll be rushing to write production code in but if I reach the limits of the spreadsheets I find myself in for work, I have a new `<-` arrow to deploy from my quiver.
+
+For [Mindshifting May](https://exercism.org/blog/12in23-calendar), I'm looking forward to tackling [Tcl](https://exercism.org/tracks/tcl) for the first time. Why not join me?