El pipe (|>): por qué cambia cómo se lee R

El operador que convierte código anidado en lectura izquierda-a-derecha. Diferencia entre |> nativo y %>%, y cuál usar a partir de R 4.1.

Por qué necesitas un pipe

Imagina que tienes un data frame ventas y quieres:

1. Filtrar solo las filas del año 2024.
2. Agrupar por región.
3. Calcular la media de ingresos por región.
4. Ordenar el resultado de mayor a menor.

Escrito sin pipe, encadenar estas operaciones produce dos opciones, ambas malas:

Opción 1, anidamiento:

arrange(
  summarise(
    group_by(
      filter(ventas, año == 2024),
      region
    ),
    media_ingresos = mean(ingresos, na.rm = TRUE)
  ),
  desc(media_ingresos)
)

Para leer esto, tu cerebro tiene que ir hacia dentro (encontrar filter en el centro), volver hacia fuera (arrange al final). Es leer un análisis al revés.

Opción 2, variables intermedias:

ventas_2024            <- filter(ventas, año == 2024)
ventas_2024_por_region <- group_by(ventas_2024, region)
ventas_resumen         <- summarise(
  ventas_2024_por_region,
  media_ingresos = mean(ingresos, na.rm = TRUE)
)
ventas_ordenadas       <- arrange(ventas_resumen, desc(media_ingresos))

Cuatro variables intermedias que no usas para nada. Cuando vuelvas a este código en una semana, no sabrás cuál es la final.

La forma nueva: el pipe

El operador |> (nativo desde R 4.1) toma lo que está a su izquierda y lo pasa como primer argumento a la función de su derecha:

ventas |>
  filter(año == 2024) |>
  group_by(region) |>
  summarise(media_ingresos = mean(ingresos, na.rm = TRUE)) |>
  arrange(desc(media_ingresos))

Léelo en voz alta: “toma ventas, filtra por año 2024, agrupa por región, resume con la media de ingresos, ordena descendentemente”. Es prosa. Es la misma operación que antes pero ahora puedes seguirla con el dedo de arriba a abajo, de izquierda a derecha.

Esto es lo que diferencia el R tidyverse del R clásico: no se leen funciones, se leen pipelines.

|> vs %>%: la diferencia real

Si lees código antiguo o tutoriales viejos, verás %>% en lugar de |>. La historia rápida:

• %>% viene del paquete magrittr (2014). Durante años fue el pipe estándar del tidyverse.
• |> es el pipe nativo de R, introducido en R 4.1 (2021). No requiere ningún paquete.

Diferencias prácticas:

	%>% (magrittr)	|> (nativo)
Requiere paquete	Sí (magrittr o dplyr)	No
Placeholder en posición != 1	.	_ solo en argumentos nombrados
Llamada sin paréntesis	Sí (df %>% nrow)	No (df \|> nrow())
Velocidad	Ligeramente más lento	Más rápido (es C interno de R)

Recomendación 2026: usa |> por defecto. Las diferencias con %>% son menores y el código sin dependencias innecesarias es mejor código. Si lees %>% en código heredado, sabes que es lo mismo conceptualmente.

El pipe es una jerarquía mental, no solo sintaxis

El pipe no es azúcar sintáctico cosmético. Cambia cómo piensas:

• Sin pipe: piensas en términos de “qué función llamo y con qué argumentos”. El sujeto del verbo es la función.
• Con pipe: piensas en términos de “qué datos tengo y qué les voy a hacer ahora”. El sujeto es el dato.

Cuando alguien que viene de Excel o SPSS pasa al pipe, suele comentar que “el pipe se entiende solo”. Eso es porque la estructura sujeto → verbo → verbo → verbo es cercana a cómo describes el análisis en una reunión: “tomé las ventas, filtré 2024, agrupé por región, calculé la media”.

Trampas habituales

• |> no admite . como placeholder en cualquier posición. Si necesitas pasar el lado izquierdo a una posición que no sea el primer argumento, hay tres opciones:
  • Con %>%: df %>% lm(y ~ x, data = .) funciona directo.
  • Con |> y argumento nombrado: df |> lm(y ~ x, data = _) funciona, pero solo si el argumento es nombrado.
  • Casos más raros: una función anónima al vuelo: df |> (\(x) algo_complicado(x))().
• Cuidado al copiar código entre |> y %>%. No siempre es 1:1, especialmente cuando hay . como placeholder. Léelo antes de pegarlo.
• Encadenar 15 pasos en un solo pipe. Si tu pipeline pasa de unos 6-8 pasos, conviene partirlo en bloques con variables intermedias significativas. El pipe es legibilidad. Un pipeline gigantesco vuelve a ser ilegible por la razón opuesta, la del túnel sin salidas.

En la siguiente entrega

Con el pipe en la mochila, podemos empezar a hacer cosas reales. Lo primero: traer datos del exterior a R. Vemos readr y los desafíos del mundo real (delimitadores raros, decimales con coma, fechas en formato europeo) en el siguiente tutorial.