Quotation.qmd

# Cuasicita {#sec-quasiquotation}

```{r, include = FALSE}
source("common.R")
```

## Introducción

Ahora que comprende la estructura de árbol del código R, es hora de volver a una de las ideas fundamentales que hacen que 'expr()' y 'ast()' funcionen: citar (poner entre comillas). En una evaluación ordenada, todas las funciones de comillas son en realidad funciones de cuasicita porque también admiten la eliminación de comillas. Donde citar es el acto de capturar una expresión no evaluada, **no citar** es la capacidad de evaluar selectivamente partes de una expresión entrecomillada. En conjunto, esto se llama cuasicitar. La cuasicita facilita la creación de funciones que combinan código escrito por el autor de la función con código escrito por el usuario de la función. Esto ayuda a resolver una amplia variedad de problemas desafiantes.

La cuasicita es uno de los tres pilares de la evaluación ordenada. Aprenderá sobre los otros dos (cuotas y máscara de datos) en el @sec-evaluation. Cuando se usa sola, la cuasicita es más útil para la programación, particularmente para generar código. Pero cuando se combina con otras técnicas, la evaluación ordenada se convierte en una poderosa herramienta para el análisis de datos.

### Estructura {.unnumbered}

-   La @sec-quasi-motivation motiva el desarrollo de la cuasicita con una función, `cement()`, que funciona como `paste()` pero cita automáticamente sus argumentos para que usted no tenga que hacerlo.

-   La @sec-quoting le brinda las herramientas para citar expresiones, ya sea que provengan de usted o del usuario, o si usa herramientas rlang o base R.

-   La @sec-unquoting introduce la mayor diferencia entre las funciones de citar de rlang y la función de citar base: quitar las comillas con `!!` y `!!!`.

-   La @sec-base-nonquote analiza las tres técnicas principales sin comillas que utilizan las funciones base de R para deshabilitar el comportamiento de comillas.

-   La @sec-tidy-dots explora otro lugar donde puedes usar `!!!`, funciones que toman `...`. También presenta el operador especial `:=`, que le permite cambiar dinámicamente los nombres de los argumentos.

-   La @sec-expr-case-studies algunos usos prácticos de las comillas para resolver problemas que naturalmente requieren cierta generación de código.

-   La @sec-history termina con un poco de historia de la cuasicitación para aquellos que estén interesados.

### Requisitos previos {.unnumbered}

Asegúrese de haber leído la descripción general de metaprogramación en el @sec-meta-big-picture para obtener una descripción general amplia de la motivación y el vocabulario básico, y que esté familiarizado con la estructura de árbol de las expresiones como se describe en la @sec-expression-details.

En cuanto al código, usaremos principalmente las herramientas de [rlang](https://rlang.r-lib.org), pero al final del capítulo también verá algunas aplicaciones poderosas junto con [purrr](https://purrr.tidyverse.org).

```{r setup, message = FALSE}
library(rlang)
library(purrr)
```

### Trabajo relacionado {.unnumbered}

\index{macros} \index{fexprs}

Las funciones de citar tienen profundas conexiones con las **macros** de Lisp. Pero las macros generalmente se ejecutan en tiempo de compilación, que no existe en R, y siempre ingresan y generan AST. Consulte @lumley-2001 para conocer un enfoque para implementarlas en R. Las funciones de citar están más estrechamente relacionadas con las funciones más esotéricas de Lisp [**fexprs**](http://en.wikipedia.org/wiki/Fexpr), donde todos los argumentos se citan por defecto. Es útil conocer estos términos cuando se busca trabajo relacionado en otros lenguajes de programación.

## Motivación {#sec-quasi-motivation}

Comenzaremos con un ejemplo concreto que ayuda a motivar la necesidad de eliminar las comillas y, por lo tanto, de las cuasicitas. Imagina que estás creando muchas cadenas uniendo palabras:

```{r}
paste("Good", "morning", "Hadley")
paste("Good", "afternoon", "Alice")
```

Estás harto y cansado de escribir todas esas comillas y, en cambio, solo quieres usar palabras simples. Con ese fin, ha escrito la siguiente función. (No se preocupe por la implementación por ahora; aprenderá sobre las piezas más adelante).

```{r}
cement <- function(...) {
  args <- ensyms(...)
  paste(purrr::map(args, as_string), collapse = " ")
}

cement(Good, morning, Hadley)
cement(Good, afternoon, Alice)
```

Formalmente, esta función cita todas sus entradas. Puede pensar en ello como poner automáticamente comillas alrededor de cada argumento. Eso no es exactamente cierto ya que los objetos intermedios que genera son expresiones, no cadenas, pero es una aproximación útil y el significado raíz del término "cita".

Esta función es buena porque ya no necesitamos escribir comillas. El problema viene cuando queremos usar variables. Es fácil usar variables con `paste()`: simplemente no las rodee con comillas.

```{r}
name <- "Hadley"
time <- "morning"

paste("Good", time, name)
```

Obviamente, esto no funciona con `cement()` porque cada entrada se cita automáticamente:

```{r}
cement(Good, time, name)
```

Necesitamos alguna forma de *dejar de citar* explícitamente la entrada para decirle a `cement()` que elimine las comillas automáticas. Aquí necesitamos que `time` y `name` se traten de manera diferente a `Good`. Cuasicitación nos da una herramienta estándar para hacerlo: `!!`, llamado "sin comillas", y pronunciado bang-bang. `!!` le dice a una función de comillas que elimine las comillas implícitas:

```{r}
cement(Good, !!time, !!name)
```

Es útil comparar `cement()` y `paste()` directamente. `paste()` evalúa sus argumentos, por lo que debemos citar donde sea necesario; `cement()` cita sus argumentos, por lo que debemos eliminar las comillas donde sea necesario.

```{r, eval = FALSE}
paste("Good", time, name)
cement(Good, !!time, !!name)
```

### Vocabulario {#sec-vocabulary}

\index{arguments!evaluated versus quoted} \index{non-standard evaluation}

La distinción entre argumentos citados y evaluados es importante:

-   Un argumento **evaluado** obedece las reglas de evaluación usuales de R.

-   Un argumento **citado** es capturado por la función y lo procesa de manera personalizada.

`paste()` evalúa todos sus argumentos; `cement()` cita todos sus argumentos.

Si alguna vez no está seguro de si un argumento se cita o se evalúa, intente ejecutar el código fuera de la función. Si no funciona o hace algo diferente, entonces se cita ese argumento. Por ejemplo, puede usar esta técnica para determinar que se cita el primer argumento de `library()`:

```{r, error = TRUE}
# Funciona
library(MASS)

# Falla
MASS
```

Hablar sobre si un argumento se cita o se evalúa es una forma más precisa de establecer si una función utiliza o no una evaluación no estándar (NSE). A veces usaré "función de comillas" como abreviatura de una función que cita uno o más argumentos, pero en general, hablaré de argumentos citados, ya que ese es el nivel en el que se aplica la diferencia.

### Ejercicios

1.  Para cada función en el siguiente código base de R, identifique qué argumentos se citan y cuáles se evalúan.

    ```{r, results = FALSE}
    library(MASS)

    mtcars2 <- subset(mtcars, cyl == 4)

    with(mtcars2, sum(vs))
    sum(mtcars2$am)

    rm(mtcars2)
    ```

2.  Para cada función en el siguiente código tidyverse, identifique qué argumentos se citan y cuáles se evalúan.

    ```{r, eval = FALSE}
    library(dplyr)
    library(ggplot2)

    by_cyl <- mtcars %>%
      group_by(cyl) %>%
      summarise(mean = mean(mpg))

    ggplot(by_cyl, aes(cyl, mean)) + geom_point()
    ```

## Citar {#sec-quoting}

\index{quoting}

La primera parte de la cuasicita es la cita: capturar una expresión sin evaluarla. Necesitaremos un par de funciones porque la expresión se puede proporcionar directa o indirectamente, a través de un argumento de función evaluado de forma perezosa. Comenzaré con las funciones de citar de rlang, luego regresaré a las proporcionadas por la base R.

### Captura de expresiones

\index{expressions!capturing} \index{expr()} \index{quoting!expr@\texttt{expr()}}

Hay cuatro funciones de citar importantes. Para la exploración interactiva, el más importante es `expr()`, que captura su argumento exactamente como se proporciona:

```{r}
expr(x + y)
expr(1 / 2 / 3)
```

(Recuerde que los espacios en blanco y los comentarios no forman parte de la expresión, por lo que no serán capturados por una función de comillas.)

`expr()` es excelente para la exploración interactiva, porque captura lo que usted, el desarrollador, escribió. No es tan útil dentro de una función:

```{r}
f1 <- function(x) expr(x)
f1(a + b + c)
```

\index{enexpr()}

Necesitamos otra función para resolver este problema: `enexpr()`. Esto captura lo que la persona que llama proporcionó a la función mirando el objeto de promesa interno que impulsa la evaluación perezosa. (@sec-promises).

```{r}
f2 <- function(x) enexpr(x)
f2(a + b + c)
```

(Se llama "en"-`expr()` por analogía para enriquecer. Enriquecer a alguien lo hace más rico; `enexpr()` un argumento lo convierte en una expresión.)

Para capturar todos los argumentos en `...`, use `enexprs()`.

```{r}
f <- function(...) enexprs(...)
f(x = 1, y = 10 * z)
```

Finalmente, `exprs()` es útil de forma interactiva para hacer una lista de expresiones:

```{r, results = FALSE}
exprs(x = x ^ 2, y = y ^ 3, z = z ^ 4)
# Forma abreviada de
# list(x = expr(x ^ 2), y = expr(y ^ 3), z = expr(z ^ 4))
```

En resumen, use `enexpr()` y `enexprs()` para capturar las expresiones suministradas como argumentos *por el usuario*. Usa `expr()` y `exprs()` para capturar expresiones que *tú* proporcionas.

### Captura de símbolos

\index{symbols!capturing} \index{ensym()}

A veces, solo desea permitir que el usuario especifique un nombre de variable, no una expresión arbitraria. En este caso, puede usar `ensym()` o `ensyms()`. Estas son variantes de `enexpr()` y `enexprs()` que comprueban que la expresión capturada es un símbolo o una cadena (que se convierte en un símbolo[^quotation-1]). `ensym()` y `ensyms()` arrojan un error si se les da algo más.

[^quotation-1]: Esto es por compatibilidad con la base R, que le permite proporcionar una cadena en lugar de un símbolo en muchos lugares: `"x" <- 1`, `"foo"(x, y)`, `c("x" = 1)`.

```{r}
f <- function(...) ensyms(...)
f(x)
f("x")
```

### Con R base

\index{expressions!capturing with base R} \index{quoting!quote@\texttt{quote()}}

Cada función rlang descrita anteriormente tiene un equivalente en base R. Su principal diferencia es que los equivalentes base no admiten la eliminación de comillas (de lo que hablaremos muy pronto). Esto las convierte en funciones de citar, en lugar de funciones de cuasicitación.

El equivalente básico de `expr()` es `quote()`:

```{r}
quote(x + y)
```

La función base más cercana a `enexpr()` es `substitute()`:

```{r}
f3 <- function(x) substitute(x)
f3(x + y)
```

\index{alist()}

La base equivalente a `exprs()` es `alist()`:

```{r}
alist(x = 1, y = x + 2)
```

El equivalente a `enexprs()` es una característica no documentada de `substitute()`[^quotation-2]:

[^quotation-2]: Descubierto por Peter Meilstrup y descrito en [R-devel el 2018-08-13](http://r.789695.n4.nabble.com/substitute-on-arguments-in-ellipsis-quot-dot-dot-dot-quot-td4751658.html).

```{r}
f <- function(...) as.list(substitute(...()))
f(x = 1, y = 10 * z)
```

Hay otras dos importantes funciones de citar base que cubriremos en otra parte:

-   `bquote()` proporciona una forma limitada de cuasicitación, y se analiza en la @sec-base-nonquote.

-   `~`, la fórmula, es una función de citar que también captura el entorno. Es la inspiración para quosures, el tema del próximo capítulo, y se discute en @sec-quosure-impl.

### Sustitución

\index{substitute()}

La mayoría de las veces verá que se usa `substitute()` para capturar argumentos no evaluados. Sin embargo, además de citar, `substitute()` también hace sustitución (¡como sugiere su nombre!). Si le da una expresión, en lugar de un símbolo, sustituirá los valores de los símbolos definidos en el entorno actual.

```{r}
f4 <- function(x) substitute(x * 2)
f4(a + b + c)
```

Creo que esto hace que el código sea difícil de entender, porque si se saca de contexto, no se puede saber si el objetivo de `substitute(x + y)` es reemplazar `x`, `y` o ambos. Si desea usar `substitute()` para la sustitución, le recomiendo que use el segundo argumento para dejar claro su objetivo:

```{r}
substitute(x * y * z, list(x = 10, y = quote(a + b)))
```

### Resumen

Al citar (es decir, capturar código), hay dos distinciones importantes:

-   ¿Lo proporciona el desarrollador del código o el usuario del código? En otras palabras, ¿es fijo (suministrado en el cuerpo de la función) o variable (suministrado a través de un argumento)?

-   ¿Quieres capturar una sola expresión o múltiples expresiones?

Esto conduce a una tabla de funciones de 2 $\times$ 2 para rlang, @tbl-quoting-rlang, y para R base, @tbl-quoting-base.

|        | Desarrollador | Usario      |
|--------|---------------|-------------|
| Uno    | `expr()`      | `enexpr()`  |
| Muchos | `exprs()`     | `enexprs()` |

: Funciones de cuasicitar de rlang {#tbl-quoting-rlang}

|        | Desarrollador | Usario                       |
|--------|---------------|------------------------------|
| Uno    | `quote()`     | `substitute()`               |
| Muchos | `alist()`     | `as.list(substitute(...()))` |

: Fuciones de cuasicitar de R base {#tbl-quoting-base}

### Ejercicios

1.  ¿Cómo se implementa `expr()`? Mira su código fuente.

2.  Compara y contrasta las siguientes dos funciones. ¿Puedes predecir la salida antes de ejecutarlos?

    ```{r, results = FALSE}
    f1 <- function(x, y) {
      exprs(x = x, y = y)
    }
    f2 <- function(x, y) {
      enexprs(x = x, y = y)
    }
    f1(a + b, c + d)
    f2(a + b, c + d)
    ```

3.  ¿Qué sucede si intenta usar `enexpr()` con una expresión (es decir, `enexpr(x + y)`? ¿Qué sucede si `enexpr()` recibe un argumento faltante?

4.  ¿En qué se diferencian `exprs(a)` y `exprs(a = )`? Piensa tanto en la entrada como en la salida.

5.  ¿Cuáles son otras diferencias entre `exprs()` y `alist()`? Lea la documentación de los argumentos con nombre de `exprs()` para averiguarlo.

6.  La documentación para `substitute()` dice:

    > La sustitución se lleva a cabo examinando cada componente del árbol de análisis de la siguiente manera:
    >
    > -   Si no es un símbolo enlazado en `env`, no cambia.
    > -   Si es un objeto de promesa (es decir, un argumento formal para una función), el espacio de expresión de la promesa reemplaza al símbolo.
    > -   Si es una variable ordinaria, se sustituye su valor, a menos que `env` sea .GlobalEnv, en cuyo caso el símbolo no se modifica.

    Cree ejemplos que ilustren cada uno de los casos anteriores.

## Remover cita {#sec-unquoting}

\index{unquoting} \index{quasiquotation} \index{expressions!unquoting}

Hasta ahora, solo ha visto ventajas relativamente pequeñas de las funciones de citar de rlang sobre las funciones de citar de base R: tienen un esquema de nomenclatura más consistente. La gran diferencia es que las funciones de comillas de rlang son en realidad funciones de cuasicita porque también pueden quitar las comillas.

Quitar las comillas le permite evaluar de forma selectiva partes de la expresión que, de lo contrario, se citarían, lo que le permite fusionar AST con una plantilla AST. Dado que las funciones base no usan la eliminación de comillas, en su lugar usan una variedad de otras técnicas, que aprenderá en la @sec-base-nonquote.

Quitar las comillas te permite evaluar selectivamente el código dentro de `expr()`, de modo que `expr(!!x)` sea equivalente a `x`. En el @sec-evaluation, aprenderá sobre otra evaluación inversa. Esto sucede fuera de `expr()`, por lo que `eval(expr(x))` es equivalente a `x`.

### Remover cita de un argumento

\index{"!"!}

Use `!!` para eliminar las comillas de un solo argumento en una llamada de función. `!!` toma una sola expresión, la evalúa y alinea el resultado en el AST.

```{r}
x <- expr(-1)
expr(f(!!x, y))
```

Creo que esto es más fácil de entender con un diagrama. `!!` introduce un marcador de posición en el AST, que se muestra con bordes punteados. Aquí, el marcador de posición `x` se reemplaza por un AST, ilustrado por una conexión punteada.

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/quotation/bang-bang.png")
```

Además de llamar a objetos, `!!` también funciona con símbolos y constantes:

```{r}
a <- sym("y")
b <- 1
expr(f(!!a, !!b))
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/quotation/simple.png")
```

Si el lado derecho de `!!` es una llamada de función, `!!` lo evaluará e insertará los resultados:

```{r}
mean_rm <- function(var) {
  var <- ensym(var)
  expr(mean(!!var, na.rm = TRUE))
}
expr(!!mean_rm(x) + !!mean_rm(y))
```

`!!` conserva la precedencia del operador porque funciona con expresiones.

```{r}
x1 <- expr(x + 1)
x2 <- expr(x + 2)

expr(!!x1 / !!x2)
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/quotation/infix.png")
```

Si simplemente pegáramos el texto de las expresiones juntas, terminaríamos con `x + 1 / x + 2`, que tiene un AST muy diferente:

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/quotation/infix-bad.png")
```

### Remover citas de una función

\index{unquoting!functions}

`!!` se usa más comúnmente para reemplazar los argumentos de una función, pero también puede usarlo para reemplazar la función. El único desafío aquí es la precedencia de los operadores: `expr(!!f(x, y))` elimina las comillas del resultado de `f(x, y)`, por lo que necesita un par de paréntesis extra.

```{r}
f <- expr(foo)
expr((!!f)(x, y))
```

Esto también funciona cuando `f` es una llamada:

```{r}
f <- expr(pkg::foo)
expr((!!f)(x, y))
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/quotation/fun.png")
```

Debido a la gran cantidad de paréntesis involucrados, puede ser más claro usar `rlang::call2()`:

```{r}
f <- expr(pkg::foo)
call2(f, expr(x), expr(y))
```

### Remover cita de un argumento faltante {#sec-unquote-missing}

\index{unquoting!missing arguments} \index{missing arguments!unquoting}

Muy ocasionalmente, es útil quitar las comillas de un argumento faltante (@sec-empty-symbol), pero el enfoque ingenuo no funciona:

```{r, error = TRUE}
arg <- missing_arg()
expr(foo(!!arg, !!arg))
```

Puedes solucionar esto con el ayudante `rlang::maybe_missing()`:

```{r}
expr(foo(!!maybe_missing(arg), !!maybe_missing(arg)))
```

### Remover cita de formas especiales

\index{unquoting!special forms} \index{special forms!unquoting}

Hay algunas formas especiales en las que quitar las comillas es un error de sintaxis. Tome `$` por ejemplo: siempre debe ir seguido del nombre de una variable, no de otra expresión. Esto significa que intentar quitar las comillas con `$` fallará con un error de sintaxis:

``` r
expr(df$!!x)
#> Error: unexpected '!' in "expr(df$!"
```

Para que la eliminación de comillas funcione, deberá usar la forma de prefijo (@sec-prefix-transform):

```{r}
x <- expr(x)
expr(`$`(df, !!x))
```

### Remover cita de muchos argumentos

\index{"!"!"!}

\index{splicing!expressions} \index{splicing|seealso {"!"!"!}} \index{unquoting!many arguments}

`!!` es un reemplazo uno a uno. `!!!` (llamado "remover cita en conjunto", y pronunciado bang-bang-bang) es un reemplazo de uno a muchos. Toma una lista de expresiones y las inserta en la ubicación del `!!!`:

<!-- GVW: breve nota para explicar por qué `!!` no se puede hacer lo suficientemente inteligente como para hacer esto automáticamente. -->

```{r}
xs <- exprs(1, a, -b)
expr(f(!!!xs, y))

# O con nombres
ys <- set_names(xs, c("a", "b", "c"))
expr(f(!!!ys, d = 4))
```

```{r, echo = FALSE, out.width = NULL}
knitr::include_graphics("diagrams/quotation/bang-bang-bang.png")
```

`!!!` se puede usar en cualquier función rlang que tome `...` independientemente de si se cita o evalúa `...` o no. Volveremos a esto en la @sec-tidy-dots; por ahora tenga en cuenta que esto puede ser útil en `call2()`.

```{r}
call2("f", !!!xs, expr(y))
```

### La ficción educada de `!!`

Hasta ahora hemos actuado como si `!!` y `!!!` fueran operadores de prefijos regulares como `+`, `-` y `!`. No lo son. Desde la perspectiva de R, `!!` y `!!!` son simplemente la aplicación repetida de `!`:

```{r}
!!TRUE
!!!TRUE
```

`!!` y `!!!` se comportan especialmente dentro de todas las funciones de citar impulsadas por rlang, donde se comportan como operadores reales con precedencia equivalente a `+` y `-` unarios. Esto requiere un trabajo considerable dentro de rlang, pero significa que puedes escribir `!!x + !!y` en lugar de `(!!x) + (!!y)`.

La mayor desventaja[^quotation-3] de usar un operador falso es que puede obtener errores silenciosos al usar incorrectamente `!!` fuera de las funciones de cuasicitas. La mayoría de las veces esto no es un problema porque '!!' se usa típicamente para eliminar las comillas de expresiones o quóstulas. Dado que el operador de negación no admite expresiones, obtendrá un error de tipo de argumento en este caso:

[^quotation-3]: Antes de R 3.5.1, había otra desventaja importante: el analizador de R trataba `!!x` como `!(!x)`. Esta es la razón por la que en las versiones antiguas de R es posible que vea paréntesis adicionales al imprimir expresiones. La buena noticia es que estos paréntesis no son reales y pueden ignorarse con seguridad la mayor parte del tiempo. La mala noticia es que se volverán reales si vuelves a analizar esa salida impresa en código R. Estas funciones de ida y vuelta no funcionarán como se espera, ya que `!(!x)` no elimina las comillas.

```{r, error = TRUE}
x <- quote(variable)
!!x
```

Pero puede obtener resultados incorrectos en silencio cuando trabaja con valores numéricos:

```{r}
df <- data.frame(x = 1:5)
y <- 100
with(df, x + !!y)
```

Dados estos inconvenientes, es posible que se pregunte por qué introdujimos una nueva sintaxis en lugar de usar llamadas a funciones normales. De hecho, las primeras versiones de la evaluación ordenada usaban llamadas a funciones como `UQ()` y `UQS()`. Sin embargo, en realidad no son llamadas de función, y fingir que lo son conduce a un modo mental engañoso. Elegimos `!!` y `!!!` como la solución menos mala:

-   Son visualmente fuertes y no se parecen a la sintaxis existente. Cuando vea `!!x` o `!!!x`, está claro que algo inusual está sucediendo.

-   Anulan una parte de la sintaxis que rara vez se usa, ya que la doble negación no es un patrón común en R[^quotation-4]. Si lo necesita, puede agregar paréntesis `!(!x)`.

[^quotation-4]: A diferencia de, por ejemplo, Javascript, donde `!!x` es un atajo de uso común para convertir un número entero en un número lógico.

### AST no estándar {#sec-non-standard-ast}

\index{ASTs!non-standard}

Sin comillas, es fácil crear AST no estándar, es decir, AST que contienen componentes que no son expresiones. (También es posible crear AST no estándar manipulando directamente los objetos subyacentes, pero es más difícil hacerlo accidentalmente). Estos son válidos y ocasionalmente útiles, pero su uso correcto está más allá del alcance de este libro. Sin embargo, es importante aprender acerca de ellos, porque se pueden dividir y, por lo tanto, imprimir de manera engañosa.

Por ejemplo, si alinea objetos más complejos, sus atributos no se imprimen. Esto puede conducir a resultados confusos:

```{r}
x1 <- expr(class(!!data.frame(x = 10)))
x1
eval(x1)
```

Tienes dos herramientas principales para reducir esta confusión: `rlang::expr_print()` y `lobstr::ast()`:

```{r}
expr_print(x1)
lobstr::ast(!!x1)
```

Otro caso confuso surge si alinea una secuencia de enteros:

```{r}
x2 <- expr(f(!!c(1L, 2L, 3L, 4L, 5L)))
x2
expr_print(x2)
lobstr::ast(!!x2)
```

También es posible crear AST regulares que no se pueden generar a partir del código debido a la precedencia del operador. En este caso, R imprimirá paréntesis que no existen en el AST:

```{r}
x3 <- expr(1 + !!expr(2 + 3))
x3

lobstr::ast(!!x3)
```

### Ejercicios

1.  Dados los siguientes componentes:

    ```{r}
    xy <- expr(x + y)
    xz <- expr(x + z)
    yz <- expr(y + z)
    abc <- exprs(a, b, c)
    ```

    Utilice la cuasicita para construir las siguientes llamadas:

    ```{r, eval = FALSE}
    (x + y) / (y + z)
    -(x + z) ^ (y + z)
    (x + y) + (y + z) - (x + y)
    atan2(x + y, y + z)
    sum(x + y, x + y, y + z)
    sum(a, b, c)
    mean(c(a, b, c), na.rm = TRUE)
    foo(a = x + y, b = y + z)
    ```

2.  Las siguientes dos llamadas imprimen lo mismo, pero en realidad son diferentes:

    ```{r}
    (a <- expr(mean(1:10)))
    (b <- expr(mean(!!(1:10))))
    identical(a, b)
    ```

    ¿Cual es la diferencia? ¿Cuál es más natural?

## No citar {#sec-base-nonquote}

\index{bquote()}

\index{unquoting!base R}

Base R tiene una función que implementa la cuasicita: `bquote()`. Utiliza `.()` para quitar las comillas:

```{r}
xyz <- bquote((x + y + z))
bquote(-.(xyz) / 2)
```

`bquote()` no es utilizado por ninguna otra función en la base R y ha tenido un impacto relativamente pequeño en cómo se escribe el código R. Existen tres desafíos para el uso efectivo de `bquote()`:

-   Solo se usa fácilmente con su código; es difícil aplicarlo a un código arbitrario proporcionado por un usuario.

-   No proporciona un operador de empalme sin comillas que le permita quitar las comillas de varias expresiones almacenadas en una lista.

-   Carece de la capacidad de manejar código acompañado de un entorno, lo cual es crucial para funciones que evalúan código en el contexto de un marco de datos, como `subset()` y amigos.

Las funciones base que citan un argumento usan alguna otra técnica para permitir la especificación indirecta. Los enfoques de Base R desactivan selectivamente las comillas, en lugar de usar la eliminación de comillas, por lo que las llamo técnicas **sin comillas**.

```{r, eval = FALSE, include = FALSE}
call <- names(pryr::find_uses("package:base", "match.call"))
subs <- names(pryr::find_uses("package:base", "substitute"))
eval <- names(pryr::find_uses("package:base", "eval"))

intersect(subs, eval)
```

Hay cuatro formas básicas que se ven en la base R:

-   Un par de funciones de citar y no citar. Por ejemplo, `$` tiene dos argumentos y el segundo argumento está entrecomillado. Esto es más fácil de ver si escribe en forma de prefijo: `mtcars$cyl` es equivalente a `` `$`(mtcars, cyl) ``. Si quiere referirse a una variable indirectamente, use `[[`, ya que toma el nombre de una variable como una cadena.

    ```{r}
    x <- list(var = 1, y = 2)
    var <- "y"

    x$var
    x[[var]]
    ```

    Hay otras tres funciones de citar estrechamente relacionadas con `$`: `subset()`, `transform()` y `with()`. Estos se ven como envoltorios alrededor de `$` solo adecuados para uso interactivo, por lo que todos tienen la misma alternativa sin comillas: `[`

    `<-`/`assign()` y `::`/`getExportedValue()` work similarly to `$`/`[`. \index{\$} \index{<-}

-   Un par de argumentos entre comillas y sin comillas. Por ejemplo, `rm()` le permite proporcionar nombres de variables simples en `...`, o un vector de caracteres de nombres de variables en `list`:

    ```{r}
    x <- 1
    rm(x)

    y <- 2
    vars <- c("y", "vars")
    rm(list = vars)
    ```

    `data()` y `save()` funcionan de forma similar. \index{rm()}

-   Un argumento que controla si un argumento diferente está entre comillas o no. Por ejemplo, en `library()`, el argumento `character.only` controla el comportamiento de las comillas del primer argumento, `package`:

    ```{r, message = FALSE}
    library(MASS)

    pkg <- "MASS"
    library(pkg, character.only = TRUE)
    ```

    `demo()`, `detach()`, `example()`, y `require()` funcionan de manera similar. \index{library()}

-   Citar si falla la evaluación. Por ejemplo, el primer argumento de `help()` no está entrecomillado si se evalúa como una cadena; si la evaluación falla, se cita el primer argumento.

    ```{r, eval = FALSE}
    # Muestra ayuda para var
    help(var)

    var <- "mean"
    # Muestra ayuda para la media
    help(var)

    var <- 10
    # Muestra ayuda para var
    help(var)
    ```

    `ls()`, `page()`, y `match.fun()` funcionan de manera similar. \index{help()}

\index{lm()}

Otra clase importante de funciones de citar son las funciones básicas de modelado y trazado, que siguen las llamadas reglas de evaluación estándar no estándar: <http://developer.r-project.org/nonstandard-eval.pdf>. Por ejemplo, `lm()` cita los argumentos `weight` y `subset`, y cuando se usa con un argumento de fórmula, la función de trazado cita los argumentos estéticos (`col`, `cex`, etc.). Toma el siguiente código: solo necesitamos `col = Species` en lugar de `col = iris$Species`.

```{r}
palette(RColorBrewer::brewer.pal(3, "Set1"))
plot(
  Sepal.Length ~ Petal.Length, 
  data = iris, 
  col = Species, 
  pch = 20, 
  cex = 2
)
```

Estas funciones no tienen opciones integradas para la especificación indirecta, pero aprenderá a simular la eliminación de comillas en la @sec-base-evaluation.

## `...` (dot-dot-dot) {#sec-tidy-dots}

\index{...}

\index{tidy dots}

<!-- GVW: esto parece estar muy lejos de la introducción anterior de `!!!` - ¿mover esto por encima de las comillas en la base R? -->

`!!!` es útil porque no es raro tener una lista de expresiones que desea insertar en una llamada. Resulta que este patrón es común en otros lugares. Considere los siguientes dos problemas motivadores:

-   ¿Qué haces si los elementos que quieres poner en `...` ya están almacenados en una lista? Por ejemplo, imagina que tienes una lista de data frames y deseas juntarlos con `rbind()`:

    ```{r}
    dfs <- list(
      a = data.frame(x = 1, y = 2),
      b = data.frame(x = 3, y = 4)
    )
    ```

    Podrías resolver este caso específico con `rbind(dfs$a, dfs$b)`, pero ¿cómo generalizas esa solución a una lista de longitud arbitraria?

-   ¿Qué hace si desea proporcionar el nombre del argumento indirectamente? Por ejemplo, imagine que desea crear un marco de datos de una sola columna donde el nombre de la columna se especifica en una variable:

    ```{r}
    var <- "x"
    val <- c(4, 3, 9)
    ```

    En este caso, podría crear un marco de datos y luego cambiar los nombres (es decir, `setNames(data.frame(val), var)`), pero esto parece poco elegante. ¿Cómo podemos hacerlo mejor?

Una forma de pensar en estos problemas es trazar paralelos explícitos con la cuasicitar:

-   La vinculación de filas de varios marcos de datos es como el empalme sin comillas: queremos incorporar elementos individuales de la lista en la llamada:

    ```{r}
    dplyr::bind_rows(!!!dfs)
    ```

    Cuando se usa en este contexto, el comportamiento de `!!!` se conoce como "salpicar" en Ruby, Go, PHP y Julia. Está estrechamente relacionado con `*args` (star-args) y `**kwarg` (star-star-kwargs) en Python, que a veces se denomina desempaquetado de argumentos. \index{splicing}

-   El segundo problema es como quitar las comillas del lado izquierdo de `=`: en lugar de interpretar literalmente `var`, queremos usar el valor almacenado en la variable llamada `var`:

    ```{r}
    tibble::tibble(!!var := val)
    ```

    Tenga en cuenta el uso de `:=` (pronunciado dos puntos-igual) en lugar de `=`. Desafortunadamente, necesitamos esta nueva operación porque la gramática de R no permite expresiones como nombres de argumentos:

    ```{r, eval = FALSE}
    tibble::tibble(!!var = value)
    #> Error: unexpected '=' in "tibble::tibble(!!var ="
    ```

    `:=` es como un órgano vestigial: es reconocido por el analizador de R, pero no tiene ningún código asociado. Parece un `=` pero permite expresiones en ambos lados, lo que lo convierte en una alternativa más flexible que `=`. Se usa en data.table por razones similares. \index{:=}

<!-- GVW: Creo que `:=` necesita/merece más que un sobrevuelo en una viñeta... -->

Base R adopta un enfoque diferente, al que volveremos en la @sec-do-call.

Decimos que las funciones que admiten estas herramientas, sin citar argumentos, tienen **puntos ordenados**[^quotation-5]. Para obtener un comportamiento de puntos ordenados en su propia función, todo lo que necesita hacer es usar `list2()`.

[^quotation-5]: Es cierto que este no es el nombre más creativo, pero sugiere claramente que es algo que se agregó a R después del hecho.

### Ejemplos

\index{attributes!attributes@\texttt{attributes()}}

Un lugar en el que podríamos usar `list2()` es crear un contenedor alrededor de `attributes()` que nos permita establecer atributos de manera flexible:

```{r}
set_attr <- function(.x, ...) {
  attr <- rlang::list2(...)
  attributes(.x) <- attr
  .x
}

attrs <- list(x = 1, y = 2)
attr_name <- "z"

1:10 %>%
  set_attr(w = 0, !!!attrs, !!attr_name := 3) %>% 
  str()
```

### `exec()`

```{=tex}
\index{exec()}
\index{list2()}
```
¿Qué sucede si desea utilizar esta técnica con una función que no tiene puntos ordenados? Una opción es usar `rlang::exec()` para llamar a una función con algunos argumentos suministrados directamente (en `...`) y otros indirectamente (en una lista):

```{r}
# Directamente
exec("mean", x = 1:10, na.rm = TRUE, trim = 0.1)

# Indirectamente
args <- list(x = 1:10, na.rm = TRUE, trim = 0.1)
exec("mean", !!!args)

# Ambos
params <- list(na.rm = TRUE, trim = 0.1)
exec("mean", x = 1:10, !!!params)
```

`rlang::exec()` también hace posible proporcionar nombres de argumentos indirectamente:

```{r}
arg_name <- "na.rm"
arg_val <- TRUE
exec("mean", 1:10, !!arg_name := arg_val)
```

Y finalmente, es útil si tiene un vector de nombres de funciones o una lista de funciones que desea llamar con los mismos argumentos:

```{r}
x <- c(runif(10), NA)
funs <- c("mean", "median", "sd")

purrr::map_dbl(funs, exec, x, na.rm = TRUE)
```

`exec()` está estrechamente relacionado con `call2()`; donde `call2()` devuelve una expresión, `exec()` la evalúa.

### `dots_list()`

\index{dots\_list()}

`list2()` proporciona otra característica útil: de forma predeterminada, ignorará cualquier argumento vacío al final. Esto es útil en funciones como `tibble::tibble()` porque significa que puedes cambiar fácilmente el orden de las variables sin preocuparte por la coma final:

```{r, results = FALSE}
# Puede mover fácilmente x a la primera entrada:
tibble::tibble(
  y = 1:5,
  z = 3:-1,
  x = 5:1,
)

# Necesita eliminar la coma de z y agregar una coma a x
data.frame(
  y = 1:5,
  z = 3:-1,
  x = 5:1
)
```

`list2()` es un envoltorio alrededor de `rlang::dots_list()` con los valores predeterminados establecidos en las configuraciones más utilizadas. Puedes tener más control llamando a `dots_list()` directamente:

-   `.ignore_empty` le permite controlar exactamente qué argumentos se ignoran. El valor predeterminado ignora un solo argumento final para obtener el comportamiento descrito anteriormente, pero puede optar por ignorar todos los argumentos faltantes o ninguno.

-   `.homonyms` controla lo que sucede si varios argumentos usan el mismo nombre:

    ```{r, error = TRUE}
    str(dots_list(x = 1, x = 2))
    str(dots_list(x = 1, x = 2, .homonyms = "first"))
    str(dots_list(x = 1, x = 2, .homonyms = "last"))
    str(dots_list(x = 1, x = 2, .homonyms = "error"))
    ```

-   Si hay argumentos vacíos que no se ignoran, `.preserve_empty` controla qué hacer con ellos. El valor predeterminado arroja un error; establecer `.preserve_empty = TRUE` en su lugar devuelve los símbolos que faltan. Esto es útil si estás usando `dots_list()` para generar llamadas a funciones.

### Con R base {#sec-do-call}

\index{splicing!base R} \index{do.call()}

Base R proporciona una navaja suiza para resolver estos problemas: `do.call()`. `do.call()` tiene dos argumentos principales. El primer argumento, `qué`, da una función para llamar. El segundo argumento, `args`, es una lista de argumentos para pasar a esa función, por lo que `do.call("f", list(x, y, z))` es equivalente a `f(x, y, z)`.

-   `do.call()` da una solución directa a `rbind()` juntando muchos marcos de datos:

    ```{r}
    do.call("rbind", dfs)
    ```

-   Con un poco más de trabajo, podemos usar `do.call()` para resolver el segundo problema. Primero creamos una lista de argumentos, luego le damos un nombre y luego usamos `do.call()`:

    ```{r}
    args <- list(val)
    names(args) <- var

    do.call("data.frame", args)
    ```

Algunas funciones básicas (incluidas `interaction()`, `expand.grid()`, `options()` y `par()`) usan un truco para evitar `do.call()`: si el primer componente de `...` es una lista, tomarán sus componentes en lugar de mirar los otros elementos de `...`. La implementación se parece a esto:

```{r}
f <- function(...) {
  dots <- list(...)
  if (length(dots) == 1 && is.list(dots[[1]])) {
    dots <- dots[[1]]
  }
  
  # Hacer algo
  ...
}
```

Otro método para evitar `do.call()` se encuentra en la función `RCurl::getURL()` escrita por Duncan Temple Lang. `getURL()` toma tanto `...` como `.dots`, que se concatenan entre sí y se parece a esto:

```{r}
f <- function(..., .dots) {
  dots <- c(list(...), .dots)
  # Hacer algo
}
```

En el momento en que lo descubrí, encontré esta técnica particularmente convincente, por lo que puede verla utilizada en todo el tidyverse. Ahora, sin embargo, prefiero el enfoque descrito anteriormente.

### Ejercicios

1.  A continuación se muestra una forma de implementar `exec()`. Describa cómo funciona. ¿Cuáles son las ideas clave?

    ```{r}
    exec <- function(f, ..., .env = caller_env()) {
      args <- list2(...)
      do.call(f, args, envir = .env)
    }
    ```

2.  Lea atentamente el código fuente de `interaction()`, `expand.grid()` y `par()`. Compare y contraste las técnicas que usan para cambiar entre puntos y comportamiento de lista.

3.  Explique el problema con esta definición de `set_attr()`

    ```{r, error = TRUE}
    set_attr <- function(x, ...) {
      attr <- rlang::list2(...)
      attributes(x) <- attr
      x
    }
    set_attr(1:10, x = 10)
    ```

## Casos de estudio {#sec-expr-case-studies}

Para concretar las ideas de la cuasicitación, esta sección contiene algunos pequeños estudios de casos que la utilizan para resolver problemas reales. Algunos de los estudios de casos también usan purrr: encuentro que la combinación de cuasicitación y programación funcional es particularmente elegante.

### `lobstr::ast()`

\index{unquoting!in ast()@in \texttt{ast()}}

La cuasicita nos permite resolver un molesto problema con `lobstr::ast()`: ¿qué sucede si ya capturamos la expresión?

```{r}
z <- expr(foo(x, y))
lobstr::ast(z)
```

Debido a que `ast()` cita su primer argumento, podemos usar `!!`:

```{r}
lobstr::ast(!!z)
```

### Map-reduce para generar código

Quasiquotation nos brinda herramientas poderosas para generar código, particularmente cuando se combina con `purrr::map()` y `purrr::reduce()`. Por ejemplo, suponga que tiene un modelo lineal especificado por los siguientes coeficientes:

```{r}
intercept <- 10
coefs <- c(x1 = 5, x2 = -4)
```

Y quieres convertirlo en una expresión como `10 + (x1 * 5) + (x2 * -4)`. Lo primero que debemos hacer es convertir el vector de nombres de personajes en una lista de símbolos. `rlang::syms()` está diseñado precisamente para este caso:

```{r}
coef_sym <- syms(names(coefs))
coef_sym
```

A continuación, debemos combinar cada nombre de variable con su coeficiente. Podemos hacer esto combinando `rlang::expr()` con `purrr::map2()`:

```{r}
summands <- map2(coef_sym, coefs, ~ expr((!!.x * !!.y)))
summands
```

En este caso, el intercepto también es parte de la suma, aunque no implica una multiplicación. Simplemente podemos agregarlo al comienzo del vector `summands`:

```{r}
summands <- c(intercept, summands)
summands
```

Finalmente, necesitamos reducir (@sec-reduce) los términos individuales en una sola suma sumando las piezas:

```{r}
eq <- reduce(summands, ~ expr(!!.x + !!.y))
eq
```

Podríamos hacer esto aún más general al permitir que el usuario proporcione el nombre del coeficiente y, en lugar de asumir muchas variables diferentes, indexar en una sola.

```{r}
var <- expr(y)
coef_sym <- map(seq_along(coefs), ~ expr((!!var)[[!!.x]]))
coef_sym
```

Y termine envolviendo esto en una función:

```{r}
linear <- function(var, val) {
  var <- ensym(var)
  coef_name <- map(seq_along(val[-1]), ~ expr((!!var)[[!!.x]]))

  summands <- map2(val[-1], coef_name, ~ expr((!!.x * !!.y)))
  summands <- c(val[[1]], summands)

  reduce(summands, ~ expr(!!.x + !!.y))
}

linear(x, c(10, 5, -4))
```

Tenga en cuenta el uso de `ensym()`: queremos que el usuario proporcione el nombre de una sola variable, no una expresión más compleja.

### Cortar un arreglo

\index{arrays!slicing}

Una herramienta ocasionalmente útil que falta en la base R es la capacidad de extraer una porción de una matriz dada una dimensión y un índice. Por ejemplo, nos gustaría escribir `slice(x, 2, 1)` para extraer el primer segmento a lo largo de la segunda dimensión, es decir, `x[, 1, ]`. Este es un problema moderadamente desafiante porque requiere trabajar con argumentos faltantes.

Tendremos que generar una llamada con varios argumentos faltantes. Primero generamos una lista de argumentos faltantes con `rep()` y `missing_arg()`, luego quitamos las comillas y los empalmamos en una llamada:

```{r}
indices <- rep(list(missing_arg()), 3)
expr(x[!!!indices])
```

Luego usamos la asignación de subconjuntos para insertar el índice en la posición deseada:

```{r}
indices[[2]] <- 1
expr(x[!!!indices])
```

Luego envolvemos esto en una función, usando un par de `stopifnot()`s para aclarar la interfaz:

```{r}
slice <- function(x, along, index) {
  stopifnot(length(along) == 1)
  stopifnot(length(index) == 1)
    
  nd <- length(dim(x))
  indices <- rep(list(missing_arg()), nd)
  indices[[along]] <- index
  
  expr(x[!!!indices])
}

x <- array(sample(30), c(5, 2, 3))
slice(x, 1, 3)
slice(x, 2, 2)
slice(x, 3, 1)
```

Un `slice()` real evaluaría la llamada generada (@sec-evaluation), pero aquí creo que es más esclarecedor ver el código que se genera, ya que esa es la parte difícil del desafío.

### Creación de funciones {#sec-new-function}

\index{anaphoric functions} \index{functions!generating with code}

Otra poderosa aplicación de las citas es la creación de funciones "a mano", usando `rlang::new_function()`. Es una función que crea una función a partir de sus tres componentes (@sec-fun-components): argumentos, cuerpo y (opcionalmente) un entorno:

```{r}
new_function(
  exprs(x = , y = ), 
  expr({x + y})
)
```

NB: Los argumentos vacíos en `exprs()` generan argumentos sin valores predeterminados.

Un uso de `new_function()` es como una alternativa a las fábricas de funciones con argumentos escalares o de símbolos. Por ejemplo, podríamos escribir una función que genere funciones que eleven una función a la potencia de un número.

```{r}
power <- function(exponent) {
  new_function(
    exprs(x = ), 
    expr({
      x ^ !!exponent
    }), 
    caller_env()
  )
}
power(0.5)
```

Otra aplicación de `new_function()` es para funciones que funcionan como `graphics::curve()`, que te permite trazar una expresión matemática sin crear una función:

```{r curve-demo, fig.width = 3.5, fig.height = 2.5, small_mar = TRUE}
curve(sin(exp(4 * x)), n = 1000)
```

En este código, `x` es un pronombre: no representa un solo valor concreto, sino que es un marcador de posición que varía en el rango de la gráfica. Una forma de implementar `curve()` es convertir esa expresión en una función con un solo argumento, `x`, y luego llamar a esa función:

```{r curve2, fig.show="hide"}
curve2 <- function(expr, xlim = c(0, 1), n = 100) {
  expr <- enexpr(expr)
  f <- new_function(exprs(x = ), expr)
  
  x <- seq(xlim[1], xlim[2], length = n)
  y <- f(x)

  plot(x, y, type = "l", ylab = expr_text(expr))
}
curve2(sin(exp(4 * x)), n = 1000)
```

Las funciones como `curve()` que usan una expresión que contiene un pronombre se conocen como funciones **anafóricas**[^quotation-6].

[^quotation-6]: Anaphoric proviene del término lingüístico "anáfora", una expresión que depende del contexto. Las funciones anafóricas se encuentran en [Arc](http://www.arcfn.com/doc/anaphoric.html) (un lenguaje parecido a Lisp), [Perl](http://www.perlmonks.org/index.pl?node_id=666047), y [Clojure](http://amalloy.hubpages.com/hub/Unhygenic-anaphoric-Clojure-macros-for-fun-and-profit).

### Ejercicios

1.  En el ejemplo del modelo lineal, podríamos reemplazar `expr()` en `reduce(summands, ~ expr(!!.x + !!.y))` con `call2()`: `reduce(summands, call2 , "+")`. Compare y contraste los dos enfoques. ¿Cuál crees que es más fácil de leer?

2.  Vuelva a implementar la transformación de Box-Cox definida a continuación usando la eliminación de comillas y `new_function()`:

    ```{r}
    bc <- function(lambda) {
      if (lambda == 0) {
        function(x) log(x)
      } else {
        function(x) (x ^ lambda - 1) / lambda
      }
    }
    ```

3.  Vuelva a implementar el `compose()` simple definido a continuación usando quasiquotation y `new_function()`:

    ```{r}
    compose <- function(f, g) {
      function(...) f(g(...))
    }
    ```

## Historia {#sec-history}

La idea de la cuasicita es antigua. Fue desarrollado por primera vez por el filósofo Willard van Orman Quine[^quotation-7] a principios de la década de 1940. Es necesario en filosofía porque ayuda a delinear con precisión el uso y la mención de palabras, es decir, distinguir entre el objeto y las palabras que usamos para referirnos a ese objeto.

[^quotation-7]: Es posible que esté familiarizado con el nombre Quine de "quines", programas de computadora que devuelven una copia de su propia fuente cuando se ejecutan.

Quasiquotation se utilizó por primera vez en un lenguaje de programación, Lisp, a mediados de la década de 1970 [@bawden-1999]. Lisp tiene una función de comillas `` ` ``, y usa `,` para quitar las comillas. La mayoría de los lenguajes con herencia Lisp se comportan de manera similar. Por ejemplo, Racket (`` ` `` y `@`), Clojure (`` ` `` y `~`) y Julia (`:` y `@`) tienen herramientas de cuasicitación que difieren solo ligeramente de Lisp . Estos idiomas tienen una función de comillas simples y debe llamarla explícitamente.

En R, sin embargo, muchas funciones citan una o más entradas. Esto introduce ambigüedad (porque necesita leer la documentación para determinar si un argumento se cita o no), pero permite un código de exploración de datos conciso y elegante. En base R, solo una función admite la cuasicita: `bquote()`, escrita en 2003 por Thomas Lumley. Sin embargo, `bquote()` tiene algunas limitaciones importantes que le impidieron tener un gran impacto en el código R (@sec-base-nonquote).

Mi intento de resolver estas limitaciones condujo al paquete lazyeval (2014-2015). Desafortunadamente, mi análisis del problema estaba incompleto y aunque lazyeval resolvió algunos problemas, creó otros. No fue hasta que comencé a trabajar con Lionel Henry en el problema que todas las piezas finalmente encajaron y creamos el marco de evaluación ordenado completo (2017). A pesar de la novedad de la evaluación ordenada, la enseño aquí porque es una teoría rica y poderosa que, una vez dominada, hace que muchos problemas difíciles sean mucho más fáciles.