R Cómo comprobar que se llama a una función personalizada dentro de una función específica de un paquete determinado

Quiero crear una función myfunque sólo se puede utilizar dentro de otra función, en mi caso dplyrs mutateo summarise. Además, no quiero depender de los dplyrcomponentes internos (por ejemplo mask$...).

Se me ocurrió una solución rápida y sucia: una función search_calling_fnque verifica todos los nombres de funciones en la pila de llamadas y busca un patrón específico en las funciones de llamada.

search_calling_fn <- function(pattern) {
  
  call_st <- lapply(sys.calls(), `[[`, 1)
  
  res <- any(unlist(lapply(call_st, function(x) grepl(pattern, x, perl = TRUE))))
  
  if (!res) {
    stop("`myfun()` must only be used inside dplyr::mutate or dplyr::summarise")
  } else {
    return()
  }
}

Esto funciona como se esperaba como muestran los dos ejemplos siguientes ( dplyr= 1.0.0)

library(dplyr)

myfun <- function() {
  search_calling_fn("^mutate|^summarise")
  NULL
}

# throws as expected no error
mtcars %>% 
  mutate(myfun())


myfun2 <- function() {
  search_calling_fn("^select")
  NULL
}

# throws as expected an error
mtcars %>% 
  mutate(myfun2())

Este enfoque tiene una laguna: myfunpodría llamarse desde una función con un nombre similar que no es una dplyrfunción. Me pregunto cómo puedo verificar desde qué espacio de nombres proviene una función en mi pila de llamadas. rlangtiene una función, call_nspero esto solo funcionará si la función se llama explícitamente con package::.... Además, cuando se usa, mutatehay mutate_colsuna función interna y mutate.data.frameun método S3 en la pila de llamadas, ambos parecen hacer que obtener el espacio de nombres sea aún más complicado.

Pensándolo bien, me pregunto si existe un enfoque mejor y más oficial para lograr el mismo resultado: solo permitir myfunque se le llame dentro de dplyrs mutateo summarise.

El enfoque debería funcionar sin importar cómo se llame a la función:

1. mutate
2. dplyr::mutate

Nota adicional

Después de discutir la respuesta de @ r2evans, me doy cuenta de que una solución debería pasar la siguiente prueba:

library(dplyr)

myfun <- function() {
  search_calling_fn("^mutate|^summarise")
  NULL
}

# an example for a function masking dplyr's mutate
mutate <- function(df, x) {
  NULL
}

# should throw an error but doesn't
mtcars %>% 
  mutate(myfun())

Por lo tanto, la función de verificación no solo debe mirar la pila de llamadas, sino también tratar de ver de qué paquete proviene una función en la pila de llamadas. Curiosamente, el depurador de RStudios muestra el espacio de nombres para cada función en la pila de llamadas, incluso para las funciones internas. Me pregunto cómo lo hace, ya environment(fun))que solo funciona en funciones exportadas.

Actualización : voy a "tomar prestado" de rlang::trace_back, ya que parece tener un método elegante (y funcional) para determinar un completo package::functionpara la mayor parte del árbol de llamadas (algunos como %>%no siempre están completamente resueltos).

(Si está tratando de reducir la hinchazón del paquete ... aunque es poco probable que lo haya hecho dplyry no purrr esté disponible , si prefiere hacer tanto en la base como sea posible, he proporcionado #==#llamadas equivalentes de base-R. Ciertamente es factible para intentar eliminar algunas de las rlangllamadas, pero de nuevo ... si está asumiendo dplyr, definitivamente tiene rlangalrededor, en cuyo caso esto no debería ser un problema).

search_calling_pkg <- function(pkgs, funcs) {
  # <borrowed from="rlang::trace_back">
  frames <- sys.frames()
  idx <- rlang:::trace_find_bottom(NULL, frames)
  frames <- frames[idx]
  parents <- sys.parents()[idx]
  calls <- as.list(sys.calls()[idx])
  calls <- purrr::map(calls, rlang:::call_fix_car)
  #==# calls <- lapply(calls, rlang:::call_fix_car)
  calls <- rlang:::add_pipe_pointer(calls, frames)
  calls <- purrr::map2(calls, seq_along(calls), rlang:::maybe_add_namespace)
  #==# calls <- Map(rlang:::maybe_add_namespace, calls, seq_along(calls))
  # </borrowed>
  calls_chr <- vapply(calls, function(cl) as.character(cl)[1], character(1))
  ptn <- paste0("^(", paste(pkgs, collapse = "|"), ")::")
  pkgres <- any(grepl(ptn, calls_chr))
  funcres <- !missing(funcs) && any(mapply(grepl, paste0("^", funcs, "$"), list(calls_chr)))
  if (!pkgres || !funcres) {
    stop("not correct")
  } else return()
}

La intención es que pueda buscar paquetes particulares y / o funciones particulares. El funcs=argumento puede ser cadenas fijas (tomadas literalmente), pero como pensé que podría querer hacer coincidir con cualquiera de las mutate*funciones (etc.), también puede convertirlo en una expresión regular. Todas las funciones deben estar completas package::funcname, no solo funcname(aunque ciertamente podría convertirlo en una expresión regular :-).

myfun1 <- function() {
  search_calling_pkg(pkgs = "dplyr")
  NULL
}
myfun2 <- function() {
  search_calling_pkg(funcs = c("dplyr::mutate.*", "dplyr::summarize.*"))
  NULL
}
mutate <- function(df, x) { force(x); NULL; }

mtcars[1:2,] %>% mutate(myfun1())
# Error: not correct

mtcars[1:2,] %>% dplyr::mutate(myfun1())
#   mpg cyl disp  hp drat    wt  qsec vs am gear carb
# 1  21   6  160 110  3.9 2.620 16.46  0  1    4    4
# 2  21   6  160 110  3.9 2.875 17.02  0  1    4    4

mtcars[1:2,] %>% mutate(myfun2())
# Error: not correct

mtcars[1:2,] %>% dplyr::mutate(myfun2())
#   mpg cyl disp  hp drat    wt  qsec vs am gear carb
# 1  21   6  160 110  3.9 2.620 16.46  0  1    4    4
# 2  21   6  160 110  3.9 2.875 17.02  0  1    4    4

Y el rendimiento parece ser significativamente mejor que la primera respuesta, aunque todavía no es un "impacto cero" en el rendimiento:

microbenchmark::microbenchmark(
  a = mtcars %>%
  dplyr::mutate(),
  b = mtcars %>%
  dplyr::mutate(myfun1())
)
# Unit: milliseconds
#  expr    min     lq     mean  median      uq     max neval
#     a 1.5965 1.7444 1.883837 1.82955 1.91655  3.0574   100
#     b 3.4748 3.7335 4.187005 3.92580 4.18140 19.4343   100

(Esta porción se guardó para la prosperidad, aunque tenga en cuenta que getAnywherese encontrará dplyr::mutateincluso si mutatese define y llama al non-dplyr anterior ).

Sembrado por los enlaces de Rui, sugiero que la búsqueda de funciones específicas podría muy bien perder nuevas funciones y / o funciones válidas pero con nombres diferentes. (No tengo un ejemplo claro). A partir de aquí, considere buscar paquetes particulares en lugar de funciones particulares.

search_calling_pkg <- function(pkgs) {
  call_st <- lapply(sys.calls(), `[[`, 1)
  res <- any(vapply(call_st, function(ca) any(pkgs %in% tryCatch(getAnywhere(as.character(ca)[1])$where, error=function(e) "")), logical(1)))
  if (!res) {
    stop("not called from packages")
  } else return()
}
myfun <- function() {
  search_calling_pkg("package:dplyr")
  NULL
}

Tenga en cuenta que esta no es una operación económica. Creo que la mayor parte del tiempo que pasamos en esto se ocupa del árbol de llamadas, tal vez no sea algo que podamos remediar fácilmente.

microbenchmark::microbenchmark(
  a = mtcars %>% mutate(),
  b = mtcars %>% mutate(myfun())
)
# Unit: milliseconds
#  expr        min         lq       mean     median        uq        max neval
#     a   1.872101   2.165801   2.531046   2.312051   2.72835   4.861202   100
#     b 546.916301 571.909551 603.528225 589.995251 612.20240 798.707300   100

Si cree que se llamará con poca frecuencia y su función toma "un poco de tiempo", entonces quizás el retraso de medio segundo no sea tan notable, pero con este ejemplo de juguete la diferencia es palpable.

Arriba @ r2evans muestra cómo package::function()se puede resolver la cuestión general de cómo comprobar si una función se llama desde dentro de otra .

Si uno no quiere depender de rlanglas funciones internas, una posible solución es usar rlang::env_name(environment(fun = ...)), sin embargo, en este caso, solo se puede verificar el espacio de nombres / paquete de la función que llama y no el nombre de la función:

library(dplyr)
library(rlang)

check_pkg <- function(pkg) {
  
  call_st <- sys.calls()
  
  res <- lapply(call_st, function(x) {
    
    .x <- x[[1]]
    
    tryCatch({
          rlang::env_name(environment(fun = eval(.x)))
        }, error = function(e) {
        NA
        })
    
  })
    
   if (!any(grepl(pkg, res, perl = TRUE))) {
      stop("`myfun()` must only be used inside dplyr verbs")
   }  
  
}


myfun1 <- function() {
  check_pkg("namespace:dplyr")
  NULL
}

custom_fc <- mutate

mutate <- function(df, x) { force(x); NULL; }

mtcars[1:2,] %>% mutate(myfun1())
#> Error in check_pkg("namespace:dplyr"): `myfun()` must only be used inside dplyr verbs

mtcars[1:2,] %>% dplyr::mutate(myfun1())
#>   mpg cyl disp  hp drat    wt  qsec vs am gear carb
#> 1  21   6  160 110  3.9 2.620 16.46  0  1    4    4
#> 2  21   6  160 110  3.9 2.875 17.02  0  1    4    4

mtcars[1:2,] %>% custom_fc(myfun1())
#>   mpg cyl disp  hp drat    wt  qsec vs am gear carb
#> 1  21   6  160 110  3.9 2.620 16.46  0  1    4    4
#> 2  21   6  160 110  3.9 2.875 17.02  0  1    4    4

^{Creado el 2020-07-13 por el paquete reprex (v0.3.0)}

Para mi problema específico para verificar si se llama a una función desde adentro, se dplyrme ocurrió una alternativa eficiente usando una llamada a across()como prueba si myfun()se llama desde adentro dplyr. A diferencia de mask$...etc. across()es una dplyrfunción exportada .

library(dplyr)
library(rlang)

check_calling_fn <- function() {
  tryCatch({
    dplyr::across()
  }, error = function(e) {
    rlang::abort("`myfun()` must only be used inside dplyr verbs")
  })
}
  

myfun <- function() {
  check_calling_fn()
  NULL
}

microbenchmark::microbenchmark(
a = mtcars %>% dplyr::mutate(myfun()),
b = mtcars %>% dplyr::mutate()
)
#> Unit: milliseconds
#>  expr      min       lq     mean   median       uq       max neval
#>     a 2.580255 2.800734 3.783082 3.105146 3.754433 21.043388   100
#>     b 1.317511 1.393168 1.713831 1.494754 1.763758  5.645019   100

myfun()
#> Error: `myfun()` must only be used inside dplyr verbs

^{Creado el 2020-07-06 por el paquete reprex (v0.3.0)}