A transformer which allows succinct sprintf format strings.
sprintf_transformer <-function(text, envir) { m <-regexpr(":.+$", text)if (m !=-1) { format <-substring(regmatches(text, m), 2)regmatches(text, m) <-"" res <-eval(parse(text = text, keep.source =FALSE), envir)do.call(sprintf, list(glue("%{format}"), res)) } else {eval(parse(text = text, keep.source =FALSE), envir) }}glue_fmt <-function(..., .envir =parent.frame()) {glue(..., .transformer = sprintf_transformer, .envir = .envir)}glue_fmt("π = {pi:.3f}")#> π = 3.142
safely transformer
A transformer that acts like purrr::safely(), which returns a value instead of an error.
safely_transformer <-function(otherwise =NA) {function(text, envir) {tryCatch(eval(parse(text = text, keep.source =FALSE), envir),error =function(e) if (is.language(otherwise)) eval(otherwise) else otherwise) }}glue_safely <-function(..., .otherwise =NA, .envir =parent.frame()) {glue(..., .transformer =safely_transformer(.otherwise), .envir = .envir)}# Default returns missing if there is an errorglue_safely("foo: {xyz}")#> foo: NA# Or an empty stringglue_safely("foo: {xyz}", .otherwise ="Error")#> foo: Error# Or output the error message in redlibrary(crayon)glue_safely("foo: {xyz}", .otherwise =quote(glue("{red}Error: {conditionMessage(e)}{reset}")))#> foo: Error: object 'xyz' not found
“Variables and Values” transformer
A transformer that expands input of the form {var_name=} into var_name = var_value, i.e. a shorthand for exposing variable names with their values. This is inspired by an f-strings feature coming in Python 3.8. It’s actually more general: you can use it with an expression input such as {expr=}.
vv_transformer <-function(text, envir) { regex <-"=$"if (!grepl(regex, text)) {return(identity_transformer(text, envir)) } text <-sub(regex, "", text) res <-identity_transformer(text, envir) n <-length(res) res <-glue_collapse(res, sep =", ")if (n >1) { res <-c("[", res, "]") }glue_collapse(c(text, " = ", res))}
set.seed(1234)description <-"some random"numbers <-sample(100, 4)average <-mean(numbers)sum <-sum(numbers)glue("For {description} {numbers=}, {average=}, {sum=}.", .transformer = vv_transformer)#> For some random numbers = [28, 80, 22, 9], average = 34.75, sum = 139.a <-3b <-5.6glue("{a=}\n{b=}\n{a * 9 + b * 2=}", .transformer = vv_transformer)#> a = 3#> b = 5.6#> a * 9 + b * 2 = 38.2
So what do we mean when we say that glue is fast? This does not mean glue is the fastest thing to use in all cases, however for the features it provides we can confidently say it is fast.
A good way to determine this is to compare it’s speed of execution to some alternatives.
base::paste0(), base::sprintf() - Functions in base R implemented in C that provide variable insertion (but not interpolation).
R.utils::gstring(), stringr::str_interp() - Provides a similar interface as glue, but using ${} to delimit blocks to interpolate.
pystr::pystr_format()1, rprintf::rprintf() - Provide a interfaces similar to python string formatters with variable replacement, but not arbitrary interpolation.
Simple concatenation
bar <-"baz"simple <- microbenchmark::microbenchmark(glue = glue::glue("foo{bar}"),gstring = R.utils::gstring("foo${bar}"),paste0 =paste0("foo", bar),sprintf =sprintf("foo%s", bar),str_interp = stringr::str_interp("foo${bar}"),rprintf = rprintf::rprintf("foo$bar", bar = bar))print(unit ="eps", order ="median", signif =4, simple)plot_comparison(simple)
While glue() is slower than paste0,sprintf() it is twice as fast as str_interp() and gstring(), and on par with rprintf().
Although paste0(), sprintf() don’t do string interpolation and will likely always be significantly faster than glue, glue was never meant to be a direct replacement for them.
rprintf() does only variable interpolation, not arbitrary expressions, which was one of the explicit goals of writing glue.
So glue is ~2x as fast as the two functions (str_interp(), gstring()), which do have roughly equivalent functionality.
It also is still quite fast, with over 6000 evaluations per second on this machine.
Vectorized performance
Taking advantage of glue’s vectorization is the best way to avoid performance. For instance the vectorized form of the previous benchmark is able to generate 100,000 strings in only 22ms with performance much closer to that of paste0() and sprintf(). NB: str_interp() does not support vectorization, and so was removed.
bar <-rep("bar", 1e5)vectorized <- microbenchmark::microbenchmark(glue = glue::glue("foo{bar}"),gstring = R.utils::gstring("foo${bar}"),paste0 =paste0("foo", bar),sprintf =sprintf("foo%s", bar),rprintf = rprintf::rprintf("foo$bar", bar = bar))print(unit ="ms", order ="median", signif =4, vectorized)plot_comparison(vectorized, log =FALSE)
pystr is no longer available from CRAN due to failure to correct installation errors and was therefore removed from further testing.↩︎
glue/inst/doc/speed.Rmd 0000644 0001762 0000144 00000007072 14156753073 014515 0 ustar ligges users ---
title: "Speed of glue"
output: rmarkdown::html_vignette
vignette: >
%\VignetteIndexEntry{Speed of glue}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
%\VignetteDepends{R.utils
R.utils,
forcats,
microbenchmark,
rprintf,
stringr,
ggplot2}
---
Glue is advertised as
> Fast, dependency free string literals
So what do we mean when we say that glue is fast? This does not mean glue is
the fastest thing to use in all cases, however for the features it provides we
can confidently say it is fast.
A good way to determine this is to compare it's speed of execution to some alternatives.
- `base::paste0()`, `base::sprintf()` - Functions in base R implemented in C
that provide variable insertion (but not interpolation).
- `R.utils::gstring()`, `stringr::str_interp()` - Provides a similar interface
as glue, but using `${}` to delimit blocks to interpolate.
- `pystr::pystr_format()`[^1], `rprintf::rprintf()` - Provide a interfaces similar
to python string formatters with variable replacement, but not arbitrary
interpolation.
```{r setup, include = FALSE}
knitr::opts_chunk$set(
collapse = TRUE, comment = "#>",
eval = as.logical(Sys.getenv("EVAL_VIGNETTES", "FALSE")),
cache = FALSE)
library(glue)
```
```{r setup2, include = FALSE}
plot_comparison <- function(x, ...) {
library(ggplot2)
library(microbenchmark)
x$expr <- forcats::fct_reorder(x$expr, x$time)
colors <- ifelse(levels(x$expr) == "glue", "orange", "grey")
autoplot(x, ...) +
theme(axis.text.y = element_text(color = colors)) +
aes(fill = expr) + scale_fill_manual(values = colors, guide = FALSE)
}
```
## Simple concatenation
```{r, message = FALSE}
bar <- "baz"
simple <-
microbenchmark::microbenchmark(
glue = glue::glue("foo{bar}"),
gstring = R.utils::gstring("foo${bar}"),
paste0 = paste0("foo", bar),
sprintf = sprintf("foo%s", bar),
str_interp = stringr::str_interp("foo${bar}"),
rprintf = rprintf::rprintf("foo$bar", bar = bar)
)
print(unit = "eps", order = "median", signif = 4, simple)
plot_comparison(simple)
```
While `glue()` is slower than `paste0`,`sprintf()` it is
twice as fast as `str_interp()` and `gstring()`, and on par with `rprintf()`.
Although `paste0()`, `sprintf()` don't do string interpolation and will likely always be
significantly faster than glue, glue was never meant to be a direct replacement
for them.
`rprintf()` does only variable interpolation, not arbitrary expressions, which
was one of the explicit goals of writing glue.
So glue is ~2x as fast as the two functions (`str_interp()`, `gstring()`), which do have
roughly equivalent functionality.
It also is still quite fast, with over 6000 evaluations per second on this machine.
## Vectorized performance
Taking advantage of glue's vectorization is the best way to avoid performance.
For instance the vectorized form of the previous benchmark is able to generate
100,000 strings in only 22ms with performance much closer to that of
`paste0()` and `sprintf()`. NB: `str_interp()` does not support
vectorization, and so was removed.
```{r, message = FALSE}
bar <- rep("bar", 1e5)
vectorized <-
microbenchmark::microbenchmark(
glue = glue::glue("foo{bar}"),
gstring = R.utils::gstring("foo${bar}"),
paste0 = paste0("foo", bar),
sprintf = sprintf("foo%s", bar),
rprintf = rprintf::rprintf("foo$bar", bar = bar)
)
print(unit = "ms", order = "median", signif = 4, vectorized)
plot_comparison(vectorized, log = FALSE)
```
[^1]: pystr is no longer available from CRAN due to failure to correct
installation errors and was therefore removed from further testing.
glue/inst/doc/transformers.Rmd 0000644 0001762 0000144 00000013676 14156753073 016151 0 ustar ligges users ---
title: "Transformers"
output: rmarkdown::html_vignette
vignette: >
%\VignetteIndexEntry{Transformers}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
Transformers allow you to apply functions to the glue input and output, before
and after evaluation. This allows you to write things like `glue_sql()`, which
automatically quotes variables for you or add a syntax for automatically
collapsing outputs.
The transformer functions simply take two arguments `text` and `envir`, where
`text` is the unparsed string inside the glue block and `envir` is the
execution environment. Most transformers will then call `eval(parse(text = text,
keep.source = FALSE), envir)` which parses and evaluates the code.
You can then supply the transformer function to glue with the `.transformer`
argument. In this way users can manipulate the text before parsing and
change the output after evaluation.
It is often useful to write a `glue()` wrapper function which supplies a
`.transformer` to `glue()` or `glue_data()` and potentially has additional
arguments. One important consideration when doing this is to include
`.envir = parent.frame()` in the wrapper to ensure the evaluation environment
is correct.
Some example implementations of potentially useful transformers follow. The
aim right now is not to include most of these custom functions within the
`glue` package. Rather, users are encouraged to create custom functions using
transformers to fit their individual needs.
```{r, include = FALSE}
knitr::opts_chunk$set(collapse = TRUE, comment = "#>")
```
```{r}
library(glue)
```
### collapse transformer
A transformer which automatically collapses any glue block ending with `*`.
```{r}
collapse_transformer <- function(regex = "[*]$", ...) {
function(text, envir) {
collapse <- grepl(regex, text)
if (collapse) {
text <- sub(regex, "", text)
}
res <- identity_transformer(text, envir)
if (collapse) {
glue_collapse(res, ...)
} else {
res
}
}
}
glue("{1:5*}\n{letters[1:5]*}", .transformer = collapse_transformer(sep = ", "))
glue("{1:5*}\n{letters[1:5]*}", .transformer = collapse_transformer(sep = ", ", last = " and "))
x <- c("one", "two")
glue("{x}: {1:5*}", .transformer = collapse_transformer(sep = ", "))
```
### Shell quoting transformer
A transformer which automatically quotes variables for use in shell commands,
e.g. via `system()` or `system2()`.
```{r}
shell_transformer <- function(type = c("sh", "csh", "cmd", "cmd2")) {
type <- match.arg(type)
function(text, envir) {
res <- eval(parse(text = text, keep.source = FALSE), envir)
shQuote(res)
}
}
glue_sh <- function(..., .envir = parent.frame(), .type = c("sh", "csh", "cmd", "cmd2")) {
.type <- match.arg(.type)
glue(..., .envir = .envir, .transformer = shell_transformer(.type))
}
filename <- "test"
writeLines(con = filename, "hello!")
command <- glue_sh("cat {filename}")
command
system(command)
```
```{r include = FALSE}
if (file.exists("test")) {
unlink("test")
}
```
### emoji transformer
A transformer which converts the text to the equivalent emoji.
```{r, eval = require("emo")}
emoji_transformer <- function(text, envir) {
if (grepl("[*]$", text)) {
text <- sub("[*]$", "", text)
glue_collapse(ji_find(text)$emoji)
} else {
ji(text)
}
}
glue_ji <- function(..., .envir = parent.frame()) {
glue(..., .open = ":", .close = ":", .envir = .envir, .transformer = emoji_transformer)
}
glue_ji("one :heart:")
glue_ji("many :heart*:")
```
### sprintf transformer
A transformer which allows succinct sprintf format strings.
```{r}
sprintf_transformer <- function(text, envir) {
m <- regexpr(":.+$", text)
if (m != -1) {
format <- substring(regmatches(text, m), 2)
regmatches(text, m) <- ""
res <- eval(parse(text = text, keep.source = FALSE), envir)
do.call(sprintf, list(glue("%{format}"), res))
} else {
eval(parse(text = text, keep.source = FALSE), envir)
}
}
glue_fmt <- function(..., .envir = parent.frame()) {
glue(..., .transformer = sprintf_transformer, .envir = .envir)
}
glue_fmt("π = {pi:.3f}")
```
### safely transformer
A transformer that acts like `purrr::safely()`, which returns a value instead of an error.
```{r}
safely_transformer <- function(otherwise = NA) {
function(text, envir) {
tryCatch(
eval(parse(text = text, keep.source = FALSE), envir),
error = function(e) if (is.language(otherwise)) eval(otherwise) else otherwise)
}
}
glue_safely <- function(..., .otherwise = NA, .envir = parent.frame()) {
glue(..., .transformer = safely_transformer(.otherwise), .envir = .envir)
}
# Default returns missing if there is an error
glue_safely("foo: {xyz}")
# Or an empty string
glue_safely("foo: {xyz}", .otherwise = "Error")
# Or output the error message in red
library(crayon)
glue_safely("foo: {xyz}", .otherwise = quote(glue("{red}Error: {conditionMessage(e)}{reset}")))
```
### "Variables and Values" transformer
A transformer that expands input of the form `{var_name=}` into `var_name = var_value`, i.e. a shorthand for exposing variable names with their values. This is inspired by an [f-strings feature coming in Python 3.8](https://docs.python.org/3.8/whatsnew/3.8.html#f-strings-now-support-for-quick-and-easy-debugging). It's actually more general: you can use it with an expression input such as `{expr=}`.
```{r}
vv_transformer <- function(text, envir) {
regex <- "=$"
if (!grepl(regex, text)) {
return(identity_transformer(text, envir))
}
text <- sub(regex, "", text)
res <- identity_transformer(text, envir)
n <- length(res)
res <- glue_collapse(res, sep = ", ")
if (n > 1) {
res <- c("[", res, "]")
}
glue_collapse(c(text, " = ", res))
}
```
```{r}
set.seed(1234)
description <- "some random"
numbers <- sample(100, 4)
average <- mean(numbers)
sum <- sum(numbers)
glue("For {description} {numbers=}, {average=}, {sum=}.", .transformer = vv_transformer)
a <- 3
b <- 5.6
glue("{a=}\n{b=}\n{a * 9 + b * 2=}", .transformer = vv_transformer)
```
glue/inst/doc/speed.R 0000644 0001762 0000144 00000003241 14172662403 014160 0 ustar ligges users ## ----setup, include = FALSE---------------------------------------------------
knitr::opts_chunk$set(
collapse = TRUE, comment = "#>",
eval = as.logical(Sys.getenv("EVAL_VIGNETTES", "FALSE")),
cache = FALSE)
library(glue)
## ----setup2, include = FALSE--------------------------------------------------
# plot_comparison <- function(x, ...) {
# library(ggplot2)
# library(microbenchmark)
# x$expr <- forcats::fct_reorder(x$expr, x$time)
# colors <- ifelse(levels(x$expr) == "glue", "orange", "grey")
# autoplot(x, ...) +
# theme(axis.text.y = element_text(color = colors)) +
# aes(fill = expr) + scale_fill_manual(values = colors, guide = FALSE)
# }
## ---- message = FALSE---------------------------------------------------------
# bar <- "baz"
#
# simple <-
# microbenchmark::microbenchmark(
# glue = glue::glue("foo{bar}"),
# gstring = R.utils::gstring("foo${bar}"),
# paste0 = paste0("foo", bar),
# sprintf = sprintf("foo%s", bar),
# str_interp = stringr::str_interp("foo${bar}"),
# rprintf = rprintf::rprintf("foo$bar", bar = bar)
# )
#
# print(unit = "eps", order = "median", signif = 4, simple)
#
# plot_comparison(simple)
## ---- message = FALSE---------------------------------------------------------
# bar <- rep("bar", 1e5)
#
# vectorized <-
# microbenchmark::microbenchmark(
# glue = glue::glue("foo{bar}"),
# gstring = R.utils::gstring("foo${bar}"),
# paste0 = paste0("foo", bar),
# sprintf = sprintf("foo%s", bar),
# rprintf = rprintf::rprintf("foo$bar", bar = bar)
# )
#
# print(unit = "ms", order = "median", signif = 4, vectorized)
#
# plot_comparison(vectorized, log = FALSE)
glue/inst/doc/engines.html 0000644 0001762 0000144 00000044012 14172662402 015253 0 ustar ligges users
glue custom knitr language engines
glue custom knitr language engines
Glue provides a few custom language engines for knitr, which allows you to use glue directly in knitr chunks.
glue engine
The first engine is the glue engine, which evaluates the chunk contents as a glue template.
1 + 1 = {1 + 1}
## 1 + 1 = 2
Maybe the most useful use of the glue engine is to set the knitr option results = 'asis' and output markdown or HTML directly into the document.
```{glue, results = 'asis', echo = FALSE}#### mtcars has **{nrow(mtcars)} rows** and _{ncol(mtcars)} columns_.```
mtcars has 32 rows and 11 columns.
If you want to pass additional arguments into the glue call, simply include them as chunk options.
```{glue, .open = "<<", .close = ">>", results = 'asis', echo = FALSE}The **median waiting time** between eruptions is <<median(faithful$waiting)>>.```
The median waiting time between eruptions is 76.
glue_sql engine
The second engine is glue_sql, which will use glue::glue_sql() to generate a SQL query and then run the query using the sql engine.
First we create a new connection to an in-memory SQLite database, and write a new table to it.
con <- DBI::dbConnect(RSQLite::SQLite(), ":memory:")mtcars$model <-rownames(mtcars)DBI::dbWriteTable(con, "mtcars", mtcars)
Next define some variables we that we can use with glue to interpolate.
var <-"mpg"tbl <-"mtcars"num <-150
Then we can use glue_sql to construct and run a query using those variables into that database. Note you need to provide the connection object as a connection chunk option.
In this example there are two type of quotes. The first is a bare backtick, these are passed directly to the SQL engine unchanged. The second is backticks inside of braces, which are specially interpreted to do the proper quoting for the given SQL engine by glue. In this example we use the sqlite engine, which uses backticks for quoting, but you would use the same backticks inside brace syntax for postgreSQL, and glue_sql() would automatically use double quotes for quoting instead.
glue/inst/doc/engines.Rmd 0000644 0001762 0000144 00000005642 14172662167 015047 0 ustar ligges users ---
title: "glue custom knitr language engines"
output: rmarkdown::html_vignette
vignette: >
%\VignetteIndexEntry{glue custom knitr language engines}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
library(glue)
```
Glue provides a few [custom language engines](https://bookdown.org/yihui/rmarkdown-cookbook/custom-engine.html#custom-engine) for knitr, which allows you to use glue directly in knitr chunks.
## `glue` engine
The first engine is the `glue` engine, which evaluates the chunk contents as a glue template.
```{glue}
1 + 1 = {1 + 1}
```
Maybe the most useful use of the `glue` engine is to set the knitr option `results = 'asis'` and output markdown or HTML directly into the document.
````markdown
`r '' ````{glue, results = 'asis', echo = FALSE}
#### mtcars has **{nrow(mtcars)} rows** and _{ncol(mtcars)} columns_.
```
````
```{glue, results = 'asis', echo = FALSE}
#### mtcars has **{nrow(mtcars)} rows** and _{ncol(mtcars)} columns_.
```
If you want to pass additional arguments into the glue call, simply include them as chunk options.
````markdown
`r '' ````{glue, .open = "<<", .close = ">>", results = 'asis', echo = FALSE}
The **median waiting time** between eruptions is <>.
```
````
```{glue, .open = "<<", .close = ">>", results = 'asis', echo = FALSE}
The **median waiting time** between eruptions is <>.
```
## `glue_sql` engine
The second engine is `glue_sql`, which will use `glue::glue_sql()` to generate a SQL query and then run the query using the [sql engine](https://bookdown.org/yihui/rmarkdown/language-engines.html#sql).
First we create a new connection to an in-memory SQLite database, and write a new table to it.
```{r}
con <- DBI::dbConnect(RSQLite::SQLite(), ":memory:")
mtcars$model <- rownames(mtcars)
DBI::dbWriteTable(con, "mtcars", mtcars)
```
Next define some variables we that we can use with glue to interpolate.
```{r}
var <- "mpg"
tbl <- "mtcars"
num <- 150
```
Then we can use `glue_sql` to construct and run a query using those variables into that database. *Note* you need to provide the connection object as a `connection` chunk option.
In this example there are two type of quotes. The first is a bare backtick, these are passed directly to the SQL engine unchanged.
The second is backticks inside of braces, which are specially interpreted to do the proper quoting for the given SQL engine by glue.
In this example we use the `sqlite` engine, which uses backticks for quoting, but you would use the same backticks inside brace syntax for postgreSQL, and `glue_sql()` would automatically use double quotes for quoting instead.
````markdown
`r '' ````{glue_sql, connection = con}
SELECT `model`, `hp`, {`var`}
FROM {`tbl`}
WHERE {`tbl`}.hp > {num}
```
````
```{glue_sql, connection = con}
SELECT `model`, `hp`, {`var`}
FROM {`tbl`}
WHERE {`tbl`}.hp > {num}
```
glue/inst/doc/transformers.R 0000644 0001762 0000144 00000010230 14172662403 015601 0 ustar ligges users ## ---- include = FALSE---------------------------------------------------------
knitr::opts_chunk$set(collapse = TRUE, comment = "#>")
## -----------------------------------------------------------------------------
library(glue)
## -----------------------------------------------------------------------------
collapse_transformer <- function(regex = "[*]$", ...) {
function(text, envir) {
collapse <- grepl(regex, text)
if (collapse) {
text <- sub(regex, "", text)
}
res <- identity_transformer(text, envir)
if (collapse) {
glue_collapse(res, ...)
} else {
res
}
}
}
glue("{1:5*}\n{letters[1:5]*}", .transformer = collapse_transformer(sep = ", "))
glue("{1:5*}\n{letters[1:5]*}", .transformer = collapse_transformer(sep = ", ", last = " and "))
x <- c("one", "two")
glue("{x}: {1:5*}", .transformer = collapse_transformer(sep = ", "))
## -----------------------------------------------------------------------------
shell_transformer <- function(type = c("sh", "csh", "cmd", "cmd2")) {
type <- match.arg(type)
function(text, envir) {
res <- eval(parse(text = text, keep.source = FALSE), envir)
shQuote(res)
}
}
glue_sh <- function(..., .envir = parent.frame(), .type = c("sh", "csh", "cmd", "cmd2")) {
.type <- match.arg(.type)
glue(..., .envir = .envir, .transformer = shell_transformer(.type))
}
filename <- "test"
writeLines(con = filename, "hello!")
command <- glue_sh("cat {filename}")
command
system(command)
## ----include = FALSE----------------------------------------------------------
if (file.exists("test")) {
unlink("test")
}
## ---- eval = require("emo")---------------------------------------------------
emoji_transformer <- function(text, envir) {
if (grepl("[*]$", text)) {
text <- sub("[*]$", "", text)
glue_collapse(ji_find(text)$emoji)
} else {
ji(text)
}
}
glue_ji <- function(..., .envir = parent.frame()) {
glue(..., .open = ":", .close = ":", .envir = .envir, .transformer = emoji_transformer)
}
glue_ji("one :heart:")
glue_ji("many :heart*:")
## -----------------------------------------------------------------------------
sprintf_transformer <- function(text, envir) {
m <- regexpr(":.+$", text)
if (m != -1) {
format <- substring(regmatches(text, m), 2)
regmatches(text, m) <- ""
res <- eval(parse(text = text, keep.source = FALSE), envir)
do.call(sprintf, list(glue("%{format}"), res))
} else {
eval(parse(text = text, keep.source = FALSE), envir)
}
}
glue_fmt <- function(..., .envir = parent.frame()) {
glue(..., .transformer = sprintf_transformer, .envir = .envir)
}
glue_fmt("π = {pi:.3f}")
## -----------------------------------------------------------------------------
safely_transformer <- function(otherwise = NA) {
function(text, envir) {
tryCatch(
eval(parse(text = text, keep.source = FALSE), envir),
error = function(e) if (is.language(otherwise)) eval(otherwise) else otherwise)
}
}
glue_safely <- function(..., .otherwise = NA, .envir = parent.frame()) {
glue(..., .transformer = safely_transformer(.otherwise), .envir = .envir)
}
# Default returns missing if there is an error
glue_safely("foo: {xyz}")
# Or an empty string
glue_safely("foo: {xyz}", .otherwise = "Error")
# Or output the error message in red
library(crayon)
glue_safely("foo: {xyz}", .otherwise = quote(glue("{red}Error: {conditionMessage(e)}{reset}")))
## -----------------------------------------------------------------------------
vv_transformer <- function(text, envir) {
regex <- "=$"
if (!grepl(regex, text)) {
return(identity_transformer(text, envir))
}
text <- sub(regex, "", text)
res <- identity_transformer(text, envir)
n <- length(res)
res <- glue_collapse(res, sep = ", ")
if (n > 1) {
res <- c("[", res, "]")
}
glue_collapse(c(text, " = ", res))
}
## -----------------------------------------------------------------------------
set.seed(1234)
description <- "some random"
numbers <- sample(100, 4)
average <- mean(numbers)
sum <- sum(numbers)
glue("For {description} {numbers=}, {average=}, {sum=}.", .transformer = vv_transformer)
a <- 3
b <- 5.6
glue("{a=}\n{b=}\n{a * 9 + b * 2=}", .transformer = vv_transformer)
