What is the correct way to put quoted strings in rlang functions?

Question

I am writing a fuction that I will use regularly to filter for dates and names in our database (and then to perform some monthly counting/calculations on them). I would like to know what is the correct way to insert and evaluate strings within rlang functions in this case?

Am I doing right by using quo to put strings into the fuction?

Example:

 business_flights = tibble(passanger_name=rep(c(rep("John RED",3),rep("Mary ORANGE",3)),4),
                              dep_date=seq(from = lubridate::ymd('2005-04-07'), 
                                           to = lubridate::ymd('2025-03-22'), length.out = 24),
                              flight_num = sample(seq(from = 99, to = 1999, by = 30), size = 24, replace = TRUE))

filter_flights = function(mytibble, name, date0, date1) {
  require(tidyverse); require(lubridate)
  flights_filtered = mytibble %>%
    filter(dep_date >= !!date0, dep_date < !!date1,
           grepl(!!name, passanger_name))
  View(flights_filtered)
}

filter_flights(mytibble = business_flights, 
               name = quo("RED"), 
               date0 = quo("2005-10-13"), 
               date1 = quo(today()))

To go one step further from @Moody_Mudskipper, I dont think you need any quasiquotaton in your example. if you take out both `quo` and `!!`, you will get the same result. If you passed a variable that you would want to filter instead of `dep_date` then you would need QQ or use the NSE *escape hatches* — Jrakru56, Nov 10 '18 at 16:19

score 0 · Accepted Answer · answered Nov 16 '18 at 21:13

Non-standard evaluation allows you to capture and manipulate expressions. In base R, this is primarily accomplished through the use of quote:

quote(x)
# x

quote( a*log10(b+5) )
# a * log10(b + 5)

However, any captured expression that consists of a single literal is itself that literal:

identical( quote(5), 5 )          # TRUE
identical( quote("a"), "a" )      # TRUE
identical( quote(FALSE), FALSE )  # TRUE
identical( quote(5+5), 10 )       # FALSE, expression is not a single literal

rlang::quo from tidyverse builds on this functionality by capturing an expression AND the environment that gave rise to that expression. Together, these define a quosure:

quo(x)
# <quosure>
# expr: ^x
# env:  global

f <- function() {quo(x)}
f()
# <quosure>
# expr: ^x
# env:  0x55b7e61d5c80

Keeping expressions next to their environments allows you to ensure that they are always evaluated in a consistent fashion, as they make their way through your code:

x <- 5
g <- function( myexpr ) {
  x <- 10
  eval_tidy( myexpr ) 
}

x                 # Evaluate expression directly in its environment
# 5

g( quote(x) )     # Evaluate expression inside g()
# 10

g( quo(x) )       # Evaluate expression in its env, while inside g()
# 5

However, when capturing a literal inside a quosure, quo assigns an empty environment to it:

quo("x")
# <quosure>
# expr: ^"x"
# env:  empty

That is because the string "x" will always evaluate to "x", regardless of what environment it's evaluated in. Because of this, there is almost never a good reason to quo a string object (or any literal for that matter). It doesn't do anything and, as pointed out in the comments, your code will work fine without it.

What is the correct way to put quoted strings in rlang functions?

1 Answers1