The MockUp - Displaying verbatim code chunks in RMarkdown and Xaringan presentations

This will be a short article, but I wanted to note it for my own future use and hopefully a discoverable resource if folks get stuck trying to do the same thing!

New knitr verbatim options

Also note that since I originally published this article in 2021-08-27, {knitr} v1.37 introduced new options for verbatim, comment and asis chunks. See the full examples in the knitr News. They may make this article obsolete!

The last option that knitr recently introduced was the concept of curly-curly (ie {{r}}) verbatim code. This is by far one one of my favorite options! See it expanded upon in this knitr Issue.

Back to the original blogpost!

I recently gave a presentation on Advanced RMarkdown use, and part of what I was displaying in my RMarkdown generated xaringan slides was literal RMarkdown code chunks. These verbatim code chunks are very useful and in some cases necessary to accurately convey a teaching example.

Notably, while these verbatim code chunks are extremely useful some difficulty can arise as you’re essentially nesting R and RMarkdown code/logic inside a RMarkdown document. In order to “tell” RMarkdown to ignore the code and simply print it out verbatim you need to use a few different techniques.

More details can be found in the RMarkdown Cookbook.

Verbatim Code Chunks

The primary problem here is we need to “tell” RMarkdown not to parse the RMarkdown code chunk as real code. So we need to account for the 3x backticks that make up an R code chunk as seen below.

```{r, echo = TRUE}
...code_goes_here...
```

`cat()` to the rescue

You can use cat() to output specific code chunks verbatim as raw text. This can be very fast, but requires you to write code by hand in text.

output_code <-
"````
```{r, eval=TRUE}`r ''`
library(dplyr)
mtcars %>% 
  group_by(cyl) %>% 
  summarize(n = n(), mean = mean(mpg))
```\n````"

cat(output_code)

````
```{r, eval=TRUE}`r ''`
library(dplyr)
mtcars %>% 
  group_by(cyl) %>% 
  summarize(n = n(), mean = mean(mpg))
```
````

We need more backticks captain!

To return unevaluated verbatim code chunks code you need N + 1 of the max backticks, so for RMarkdown chunks that have 3x backticks, you need to wrap it in 4x backticks on either side of the code.

You also need to invalidate the code chunk by adding a blank r '' to the end of the existing code chunk (ie immediately after the {r} like so:

```{r}`r''`
...code_goes_here...
```

As a code example I can wrap my code in 4x backticks around the 3x backticks, also note the invalidated r expression after the {r}.

````
```{r}`r ''`
library(dplyr)
mtcars %>% 
  group_by(cyl) %>% 
  summarize(n = n(), mean = mean(mpg))
```
````

That rendered inside RMarkdown outputs:

```{r}
library(dplyr)
mtcars %>% 
  group_by(cyl) %>% 
  summarize(n = n(), mean = mean(mpg))
```

However you may notice that there’s no grey code background for the code chunk. To format it, we can also add the code type to the end of the 4x backticks for formatting purposes. I have a panelset of some of the various code types appended to the 4x backticks below. This affects some highlighting of specific functions/strings/etc in the code as well.

A note here is that my blog is written in distill, so what you see here is not identical to xaringan which is built on remark.js. As such, I’ve included the distill output below, and after that another embedded version of a minimal xaringan presentation. In xaringan there is also the highlightStyle argument in the YAML which allows for a lot of customization of the code chunk/code/comments colors. The various options for this argument are at the bottom of the remark.js wiki.