Question

我正在尝试使用一系列lapply调用来构建curried函数列表，理想情况是在最后lapply调用时，返回最终的期望值。 currying有效，但lapply似乎总是在第二个应用程序之后应用列表中的最后一个元素。

示例：

curry <- function(fn, ...) {
  arglist <- list(...)
  function(...) {
    do.call(fn, append(arglist, list(...)))
  }
}
# rcurry is used only to init the first lapply.
rcurry <- function(v1, fn, ...) {
  arglist <- append(list(v1), list(...))
  function(...) {
    do.call(fn, append(arglist, list(...)))
  }
}

myadd <- function(a,b,c) {
  a+b+c
}

这可以按预期工作：

# you can achieve the same by closure:
# curry.a <- lapply(c(10, 1000), FUN = function(a) { curry(myadd, a) })
curry.a <- lapply(list(10, 1000), rcurry, myadd)
curry.a[[1]](1,2)
curry.a[[2]](1,2)

# > [1] 13
# > [1] 1003

lapply的下一个curry会破坏范围“：

# this does give the desired output:
# curry.a.b <- list(curry(curry.a[[1]], 1), curry(curry.a[[2]], 1))
curry.a.b <- lapply(curry.a, curry, 1)
curry.a.b[[1]](2)
curry.a.b[[2]](2)

# > [1] 1003
# > [1] 1003

它似乎不是curry或rcurry函数的结果。使用roxygen的{{1}}函数可以做同样的事情。通过上面的闭包或使用Curry创建curry.a也会产生相同的结果。

当然最后的咖喱：

curry.a <- list(curry(myadd, 10), curry(myadd, 1000))

这里发生了什么？

Answer 1

fn中的

curry未在函数范围内进行求值，因此它为promise。如果你force那么你可以得到你期望的结果：

curry <- function(fn, ...) {
  force(fn)
  arglist <- list(...)
  function(...) {
    do.call(fn, append(arglist, list(...)))
  }
}

然后，

> curry.a.b <- lapply(curry.a, curry, 1)
> curry.a.b[[1]](2)
[1] 13
> curry.a.b[[2]](2)
[1] 1003
> 
> curry.a.b.c <- lapply(curry.a.b, curry, 2)
> lapply(curry.a.b.c, do.call, list())
[[1]]
[1] 13

[[2]]
[1] 1003

在内部，lapply生成一个本地变量X，每次调用函数都会引用它。如果在调用X时未在每个函数中评估lapply，则X是承诺。致电lapply后，来自X的所有函数调用中的lapply返回相同（即最后）的值。所以lapply类似于：

f0 <- function(i) function() i
f1 <- function(i) {force(i); function() i}

f <- local({
 r0 <- list()
 r1 <- list()
 for (i in 1:2) {
    r0[[i]] <- f0(i)
    r1[[i]] <- f1(i)
 }
 list(r0 = r0, r1 = r1)
})

然后，

> f$r0[[1]]()
[1] 2
> f$r1[[1]]()
[1] 1
> f$r0[[2]]()
[1] 2
> f$r1[[2]]()
[1] 2

为什么在重复调用lapply后，闭包中的变量值会丢失？

1 个答案: