Question

在以下示例中，我创建了add_timing函数运算符。输入是一个函数（比如mean），它返回一个与mean相同的函数，但报告函数完成所需的时间。请参阅以下示例：

library(pryr)

add_timing = function(input_function, specific_info) {
  if (missing(specific_info)) specific_info = function(l) 'That'
  function(...) {
    relevant_value = specific_info(list(...))
    start_time = Sys.time()
    res = input_function(...)
    cat(sprintf('%s took', relevant_value), difftime(Sys.time(), start_time, units = 'secs'), 'sec', '\n')
    res
  }
}
timed_mean = add_timing(mean)
# > timed_mean(runif(10000000))
# That took 0.4284899 sec 
# [1] 0.4999762

接下来我尝试使用pryr::compose创建相同的timed_mean函数（我喜欢语法）：

timed_mean_composed = pryr::compose(add_timing, mean)

但这确实为我提供了所需的输出：

# > timed_mean_composed(runif(100))
# function(...) {
#        relevant_value = specific_info(list(...))
#        start_time = Sys.time()
#        res = input_function(...)
#        cat(sprintf('%s took', relevant_value), difftime(Sys.time(), start_time, units = 'secs'), 'sec', '\n')
#        res
#      }

似乎compose操作不会导致实际执行add_timing函数。只有在调用该函数后，新的timed_mean_compose才会显示正确的函数输出。

基于来自@HadleyWickham的Advanced R的following example，我希望这可以像我使用它一样工作（参见下面的摘录）：

dot_every <- function(n, f) {
  i <- 1
  function(...) {
    if (i %% n == 0) cat(".")
    i <<- i + 1
    f(...)
  }
}
download <- pryr::compose(
  partial(dot_every, 10),
  memoise,
  partial(delay_by, 1),
  download_file
)

使用dot_every函数运算符的方式与我上面使用add_timing的方式相同。

我错过了什么？

Answer 1

不同之处在于，在您第一次尝试时，您正在呼叫

(add_timing(mean))(runif(1e7)

并使用compose语法调用与

更相似的内容

add_timing(mean(runif(1e7))

这些并不完全相同。实际上，pryr compose函数实际上是将语法扩展为更像

的语法

x <- runif(1e7)
x <- mean(x)
x <- add_timing(x)

也许看着这会有帮助

a <- function(x) {print(paste("a:", x));x}
b <- function(x) {print(paste("b:", x));x}
x <- pryr::compose(a,b)(print("c"))
# [1] "c"
# [1] "b: c"
# [1] "a: c"

请注意a之后才会调用b。这意味着a无法计算时间b。 compose不是创建计时器包装器的合适方法。

Answer 2

问题在于pryr::compose的目的是做一些与您在初始示例中尝试做的完全不同的事情。您想要创建一个函数工厂（称为add_timing），它将一个函数作为输入并返回一个新函数作为输出，它与输入函数执行相同的操作，但需要额外的时间打印。我会写如下：

add_timing <- function(FUN) { function(...) { print(system.time(r <- FUN(...))); r }}
mean(1:5)
# [1] 3
add_timing(mean)(1:5)
#    user  system elapsed 
#       0       0       0 
# [1] 3

相反，compose函数返回一个函数，该函数表示要按顺序计算的一系列函数。 ? compose中的示例在此处很有用。以下是一个以此为基础的示例：

add1 <- function(x) x + 1
times2 <- function(x) x * 2

# the following two are identical:
add1(1)
# [1] 2
compose(add1)(1)
# [1] 2

# the following two are identical:
times2(1) 
# [1] 2
compose(times2)(1)
# [1] 2

当嵌套顺序很重要时，

compose对嵌套很有用：

add1(times2(2))
# [1] 5
compose(add1, times2)(2)
# [1] 5

times2(add1(2))
# [1] 6
compose(times2, add1)(2)
# [1] 6

这意味着您的示例不起作用的原因是因为您的函数实际上并未以compose的工作方式嵌套。在您的示例中，您要求system.time例如计算评估3的时间（mean的输出），而不是评估mean(1:5)的时间}。

使用函数运算符的Compose函数无法按预期工作

2 个答案: