Closures and factories

A factory returns a function that closes over bindings from the factory's frame. Those free variables stay live in the returned function's enclosing environment — lexical capture, not a copy of values at call time for mutable cells.

Prefer a private e <- new.env(parent = emptyenv()) (or a list of cells updated via <<- only inside the factory) over top-level <<-. The still uses assign/get on a sealed env so state is private and does not pollute .GlobalEnv.

environment(f) of the returned closure is the factory frame (or the private env you attached). Two factories yield independent counters: each closure owns its own captured cell.

local({ ... }) can also mint a closure with a fresh frame. Expert rule: return functions that close over state; avoid <<- walking into .GlobalEnv for library code.

Misses: assuming each call to the factory shares one global counter, using Python nonlocal keywords, or mutating a captured numeric with n <- n + 1 without <<-/assign (that creates a local n and leaves the outer cell unchanged).

make_counter <- function(start = 0L) {
  e <- new.env(parent = emptyenv())
  assign("n", as.integer(start), envir = e)
  function(step = 1L) {
    assign("n", get("n", envir = e) + as.integer(step), envir = e)
    get("n", envir = e)
  }
}
a <- make_counter(0L)
b <- make_counter(10L)
print(c(a(), a(2L), b(), environment(a) != environment(b)))