Inline code with R Markdown
R Markdown is a well-known tool for reproducible science in R. In this article, I will focus on a few tricks with R inline code.
Some time ago, I was writing a vignette for my package WordR. I was using R Markdown. At one point I wanted to show `r expression` in the output, exactly as it is shown here, as an inline code block.
In both R Markdown and Markdown, we can write `abc` to show abc (I will use the blue colour for code blocks showing code as it appears in Rmd file, whereas the default colour will be showing the rendered output). What is not obvious is that you can use double backticks to escape single backticks in the code block. So code like this: `` `abc` `` (mind the spaces!) produces this `abc`.
Now as an exercise, you can guess how I produced the `` `abc` `` block above. Yes, indeed, I have ``` `` `abc` `` ``` in the Rmd source file. And we can go on like this ad infinitum (can we?).
OK, but I wanted to produce `r expression`. Learning the lesson above, we can try `` `r expression` ``. But trying this, I was getting an error:
processing file: codeBlocks.Rmd
Quitting from lines 12-22 (codeBlocks.Rmd) Error in vapply(x, format_sci_one, character(1L), ..., USE.NAMES = FALSE) : values must be length 1,
but FUN(X[[1]]) result is length 0
Calls: ... paste -__ hook -__ .inline.hook -__ format_sci -__ vapply
Execution halted
Obviously, the R Markdown renderer is trying to evaluate the expression. So it seems that R Markdown renderer does not know that it should (should it?) skip R inline code blocks which are enclosed by double backticks.
Solution
Making a long (and yes, I spent some time to find a solution) story short. The correct code block to produce `r expression` is `` `r &quot;\u0060r expression\u0060&quot;` ``.
Short explanation how it works: \\u0060 is an Unicode representation of the backtick (`). So first, the R Markdown renderer finds the R expression within the double backticks and it evaluates it. Important here is the usage of the Unicode for backtick, since using backtick within the expression would result in an error. (We are lucky, that the R Markdown renderer is not running recursively, finding again the R code block and evaluating it again.) So once the R Markdown is done, the Markdown is just seeing `` `r expression` `` in the temporary .md file, and it evaluates it correctly to `r expression` in the HTML output.
If you want to see (much) more, just look at the source R Markdown file for this article here. Do you know a better, more elegant solution? If you do, please use the discussion below.
Epilogue
Some time after I sent the draft of this blog to the RViews admin, I got a reply (thank you!) which pointed to the knitr FAQ page, specifically question number 7 (and a new post from author of knitr package explaining it a little further). It suggests probably more elegant solution of using
Some text before inline code `` `r
expression` `` and some code after
(mind the newline!) that will produce Some text before inline code `r expression` and some text after or use `` `r knitr::inline_expr(&quot;expression&quot;)` `` which produces similarly `r expression`.
But, I believe this post (especially its source) might still help someone to understand how the R inline code is evaluated.