Tutorial on using Quotes

pacman::p_load(tidyverse,lubridate,rlang)

Suppose we want to put double quotation marks around a group of words.

words<-"Monday, Tuesday, Wednesday, Thursday,Friday"
paste("2016-06-01",today(),sep = ",")

[1] "2016-06-01,2017-12-15"

sapply(strsplit(words, '[, ]+'), function(x) toString(dQuote(x)))

[1] "“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”"

cat(sapply(strsplit(words, '[, ]+'), function(x) toString(dQuote(x))))

“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”

cat(sapply(strsplit(words, '[, ]+'), function(x) toString(sQuote(x))))

‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’

Hmisc::Cs(words)

[1] "words"

cat(sapply(strsplit(paste("2016-06-01",today(),sep = ","), '[, ]+'), function(x) toString(dQuote(x))))

“2016-06-01”, “2017-12-15”

paste(dQuote(sub(" ","",unlist(strsplit(words,split = ",")))),collapse = ", ")

[1] "“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”"

#cat(paste(sQuote("2016-06-01"),sQuote(end),sep=","), "\n")
#cat(paste(dQuote("2016-06-01"),dQuote(end),sep=","), "\n")

as.vector(words)

[1] "Monday, Tuesday, Wednesday, Thursday,Friday"

Hmisc::Cs(quote(as.vector(words)))

[1] "quote(as.vector(words))"

dQuote(words)

[1] "“Monday, Tuesday, Wednesday, Thursday,Friday”"

w=as.list(words)
sapply(as.list(words),dQuote)

[1] "“Monday, Tuesday, Wednesday, Thursday,Friday”"

strsplit(words, '[, ]+')

[[1]]
[1] "Monday"    "Tuesday"   "Wednesday" "Thursday"  "Friday"   

sapply(strsplit(words, '[, ]+'),dQuote)

     [,1]         
[1,] "“Monday”"   
[2,] "“Tuesday”"  
[3,] "“Wednesday”"
[4,] "“Thursday”" 
[5,] "“Friday”"   

quo(w)

<quosure: global>
~w

end=today()
cat(paste(sQuote("2016-06-01"),sQuote(end),sep=","), "\n")

‘2016-06-01’,‘2017-12-15’ 

cat(paste(dQuote("2016-06-01"),dQuote(end),sep=","), "\n")

“2016-06-01”,“2017-12-15” 

# quo() is a quotation function just like expr() and quote():
expr(mean(1:10 * 2))

mean(1:10 * 2)

quo(mean(1:10 * 2))

<quosure: global>
~mean(1:10 * 2)

# It supports quasiquotation and allows unquoting (evaluating
# immediately) part of the quoted expression:
quo(mean(!! 1:10 * 2))

<quosure: global>
~mean(c(2, 4, 6, 8, 10, 12, 14, 16, 18, 20))

quo(!! mean(1:10 * 2))

<quosure: empty>
~11

# What makes quo() often safer to use than quote() and expr() is
# that it keeps track of the contextual environment. This is
# especially important if you're referring to local variables in
# the expression:
var <- "foo"
quo <- quo(var)
quo

<quosure: global>
~var

quo(!!var)

<quosure: empty>
~"foo"

eval_tidy(var)

[1] "foo"

# Here `quo` quotes `var`. Let's check that it also captures the
# environment where that symbol is defined:
identical(get_env(quo), get_env())

[1] TRUE

env_has(quo, "var")

[1] TRUE

# Keeping track of the environment is important when you quote an
# expression in a context (that is, a particular function frame)
# and pass it around to other functions (which will be run in their
# own evaluation frame):
fn <- function() {
  foobar <- 10
  quo(foobar * 2)
}
quo <- fn()
quo

<quosure: local>
~foobar * 2

# `foobar` is not defined here but was defined in `fn()`'s
# evaluation frame. However, the quosure keeps track of that frame
# and is safe to evaluate:
eval_tidy(quo)

[1] 20

# Quoting as a quosure is necessary to preserve scope information
# and make sure objects are looked up in the right place. However,
# there are situations where it can get in the way. This is the
# case when you deal with non-tidy NSE functions that do not
# understand formulas. You can inline the RHS of a formula in a
# call thanks to the UQE() operator:
nse_function <- function(arg) substitute(arg)
var <- locally(quo(foo(bar)))
quo(nse_function(UQ(var)))

<quosure: global>
~nse_function(~foo(bar))

quo(nse_function(UQE(var)))

<quosure: global>
~nse_function(foo(bar))

# This is equivalent to unquoting and taking the RHS:
quo(nse_function(!! get_expr(var)))

<quosure: global>
~nse_function(foo(bar))

# One of the most important old-style NSE function is the dollar
# operator. You need to use UQE() for subsetting with dollar:
var <- quo(cyl)
quo(mtcars$UQE(var))

<quosure: global>
~mtcars$cyl

# `!!`() is also treated as a shortcut. It is meant for situations
# where the bang operator would not parse, such as subsetting with
# $. Since that's its main purpose, we've made it a shortcut for
# UQE() rather than UQ():
var <- quo(cyl)
quo(mtcars$`!!`(var))

<quosure: global>
~mtcars$cyl

# When a quosure is printed in the console, the brackets indicate
# if the enclosure is the global environment or a local one:
locally(quo(foo))

<quosure: local>
~foo

# Literals are enquosed with the empty environment because they can
# be evaluated anywhere. The brackets indicate "empty":
quo(10L)

<quosure: empty>
~10L