Assignment, Names and Values

# The five assignment operators and what each one returns.
shelf_name <- "Main hall"
loan_limit = 3L # nolint: assignment_linter.
"Reading room" -> annex_name # nolint: assignment_linter.
c(shelf_name, annex_name)
#> [1] "Main hall"    "Reading room"
loan_limit
#> [1] 3

# An assignment is an expression whose value is the assigned value, returned
# invisibly. Parentheses make it visible; chaining works because of it.
(copies <- 4L)
#> [1] 4
shelf_a <- shelf_b <- shelf_c <- 0L
c(shelf_a, shelf_b, shelf_c)
#> [1] 0 0 0

# Leftwards forms group right to left, the rightwards forms left to right.
first = second <- 7L # nolint: assignment_linter.
c(first, second)
#> [1] 7 7

# The superassignment forms are covered further down; at the top level they
# behave like the plain forms, because the global environment is searched.
global_count <<- 1L # nolint: assignment_linter.
2L ->> other_count # nolint: assignment_linter.
c(global_count, other_count)
#> [1] 1 2

# An assignment is a call: the backquoted operator is an ordinary function.
`<-`(from_call, 99L)
from_call
#> [1] 99

# The parser rewrites the rightwards forms into the leftwards ones.
quote(5 -> x)
#> x <- 5
quote(5 ->> x)
#> x <<- 5
parse(text = "x = 5")[[1L]]
#> x = 5
class(parse(text = "x = 5")[[1L]])
#> [1] "="
class(quote(x <- 5))
#> [1] "<-"
as.list(quote(x <- 5))
#> [[1]]
#> `<-`
#>
#> [[2]]
#> x
#>
#> [[3]]
#> [1] 5

# Copies of each title held in three rooms.
stock <- c(main = 4L, annex = 2L, reading = 7L)

# "stock[2] <- 9L" is sugar for calling "[<-" and assigning the result back.
by_hand <- stock
by_hand <- `[<-`(by_hand, 2L, value = 9L)
stock[2L] <- 9L
identical(stock, by_hand)
#> [1] TRUE

# Nested targets are evaluated from the inside out.
names(stock)[3L] <- "reading room"
stock
#>         main        annex reading room
#>            4            9            7
by_hand <- `names<-`(
  by_hand,
  value = `[<-`(names(by_hand), 3L, value = "reading room")
)
identical(stock, by_hand)
#> [1] TRUE

# During the replacement the object is also bound to the name "*tmp*".
`peek<-` <- function(x, value) {
  cat("*tmp* visible inside:", exists("*tmp*", envir = parent.frame()), "\n")
  x
}
peek(stock) <- 1L
#> *tmp* visible inside: TRUE
exists("*tmp*")
#> [1] FALSE

# Removing and storing NULL: R FAQ 7.1.
shelf <- list(title = "Paper Moons", year = 2005L, pages = 88L)
shelf[["year"]] <- NULL
names(shelf)
#> [1] "title" "pages"
shelf["year"] <- list(NULL)
names(shelf)
#> [1] "title" "pages" "year"
length(shelf)
#> [1] 3

# A complex superassignment looks the target up in the enclosing environments
# but evaluates the index and the value where the assignment is written.
rooms <- c(a = 1, b = 2)
pick <- 1
local({
  rooms <- c(A = 10, B = 11)
  pick <- 2
  rooms[pick] <<- rooms[pick] + 1
})
rooms
#>  a  b
#>  1 12

# Assignment to an element of an object that does not exist is an error.
tryCatch(
  missing_shelf[["year"]] <- 2005L,
  error = conditionMessage
)
#> [1] "object 'missing_shelf' not found"

# "<<-" searches the enclosing environments for an existing binding and
# changes it there; the counter keeps its state between calls.
make_loan_counter <- function() {
  loans_made <- 0L
  function() {
    loans_made <<- loans_made + 1L # nolint: assignment_linter.
    loans_made
  }
}
next_loan <- make_loan_counter()
next_loan()
#> [1] 1
next_loan()
#> [1] 2
second_counter <- make_loan_counter()
second_counter()
#> [1] 1

# When no enclosing environment has the name, "<<-" creates it in the global
# environment, which is rarely what the author meant.
record_loan <- function() {
  last_loan <<- "L061" # nolint: assignment_linter, object_usage_linter.
  invisible(NULL)
}
exists("last_loan")
#> [1] FALSE
record_loan()
exists("last_loan")
#> [1] TRUE
last_loan
#> [1] "L061"

# The search finds bindings anywhere on the way out, including locked ones in
# attached packages, so a "<<-" cannot create a global that masks base R.
set_pi <- function() {
  pi <<- 3 # nolint: assignment_linter.
}
tryCatch(set_pi(), error = conditionMessage)
#> [1] "cannot change value of locked binding for 'pi'"
pi
#> [1] 3.141593

# The search starts in the enclosure of the running function, so the nearest
# enclosing binding changes and the global one with the same name is left alone.
total <- 100
outer_fn <- function() {
  total <- 1
  inner_fn <- function() {
    total <<- total + 1 # nolint: assignment_linter.
  }
  inner_fn()
  inner_fn()
  total
}
outer_fn()
#> [1] 3
total
#> [1] 100

# The explicit alternative names the environment.
log_entry <- function(entry) {
  assign("last_entry", entry, envir = globalenv())
}
log_entry("returned L001")
last_entry
#> [1] "returned L001"

books <- read.csv("books.csv")

# assign() and get() take the name as a string.
assign("current_shelf", "Main hall")
get("current_shelf")
#> [1] "Main hall"
exists("current_shelf")
#> [1] TRUE
exists("no_such_shelf")
#> [1] FALSE

# get0() combines exists() and get(): a default instead of an error.
get0("no_such_shelf", ifnotfound = "unknown")
#> [1] "unknown"

# The environment is an argument; a new environment is a tidy place for
# names that are made up at run time.
loan_room <- new.env()
for (i in seq_len(3L)) {
  assign(paste0("loan_", i), i * 7L, envir = loan_room)
}
sort(ls(loan_room))
#> [1] "loan_1" "loan_2" "loan_3"
get("loan_2", envir = loan_room)
#> [1] 14
mget(c("loan_1", "loan_3"), envir = loan_room)
#> $loan_1
#> [1] 7
#>
#> $loan_3
#> [1] 21
#>
mget(c("loan_1", "loan_9"), envir = loan_room, ifnotfound = list(NA))
#> $loan_1
#> [1] 7
#>
#> $loan_9
#> [1] NA
#>

# inherits = TRUE (the default for get and exists) walks up the enclosures.
exists("loan_1")
#> [1] FALSE
exists("loan_1", envir = loan_room)
#> [1] TRUE
exists("books", envir = loan_room)
#> [1] TRUE
exists("books", envir = loan_room, inherits = FALSE)
#> [1] FALSE

# mode skips a binding that is not of the requested kind.
c <- 21L
get("c", mode = "function")(1, 2)
#> [1] 1 2
exists("c", mode = "numeric")
#> [1] TRUE
exists("c", mode = "function")
#> [1] TRUE
rm(c)

# assign() does not dispatch replacement functions: it makes an object whose
# name is the string.
scores <- c(10, 20, 30)
assign("scores[1]", 99) # nolint: object_name_linter.
scores
#> [1] 10 20 30
get("scores[1]")
#> [1] 99

# The same loop with a named list needs no assign() at all.
loan_days_by_id <- list()
for (i in seq_len(3L)) {
  loan_days_by_id[[paste0("loan_", i)]] <- i * 7L
}
str(loan_days_by_id)
#> List of 3
#>  $ loan_1: int 7
#>  $ loan_2: int 14
#>  $ loan_3: int 21
unlist(loan_days_by_id)
#> loan_1 loan_2 loan_3
#>      7     14     21

# An environment is the exception to copy-on-modify: every name bound to it
# sees every change.
desk <- new.env()
desk$returns <- 0L
cart <- desk
cart$returns <- cart$returns + 1L
desk$returns
#> [1] 1
identical(desk, cart)
#> [1] TRUE

# A function that receives an environment changes the caller's object.
log_return <- function(env) {
  env$returns <- env$returns + 1L
  invisible(env)
}
log_return(desk)
log_return(cart)
desk$returns
#> [1] 3

# A function that receives a list changes only its own copy.
desk_list <- list(returns = 0L)
log_return_list <- function(shelf) {
  shelf$returns <- shelf$returns + 1L
  shelf
}
invisible(log_return_list(desk_list))
desk_list$returns
#> [1] 0

# Attributes of an environment are shared too (the language definition warns
# about this), and an environment cannot be traced.
attr(desk, "label") <- "front desk"
attr(cart, "label")
#> [1] "front desk"
tryCatch(tracemem(desk), error = conditionMessage)
#> [1] "'tracemem' is not useful for promise and environment objects"

# as.list() copies the bindings into a list, which is an ordinary value.
snapshot <- as.list(desk)
desk$returns <- 100L
snapshot$returns
#> [1] 3
desk$returns
#> [1] 100

# A closure keeps its state in an environment, and "<<-" modifies it.
make_register <- function() {
  entries <- character()
  list(
    add = function(entry) {
      entries <<- c(entries, entry) # nolint: assignment_linter.
    },
    all = function() entries
  )
}
register <- make_register()
register$add("L001")
register$add("L002")
register$all()
#> [1] "L001" "L002"
other <- make_register()
other$all()
#> character(0)

# Locking an environment stops names being added or removed; locking its
# bindings also stops the values being changed.
config <- new.env()
config$loan_days <- 21L
config$fine_per_day <- 0.25
lockEnvironment(config, bindings = TRUE)
tryCatch(config$loan_days <- 14L, error = conditionMessage)
#> [1] "cannot change value of locked binding for 'loan_days'"
tryCatch(config$grace_days <- 3L, error = conditionMessage)
#> [1] "cannot add bindings to a locked environment"
tryCatch(rm("loan_days", envir = config), error = conditionMessage)
#> [1] "cannot remove bindings from a locked environment"
config$loan_days
#> [1] 21

# Two object systems whose objects are environments, so they are modified in
# place. R6 is an add-on package (version 2.6.1 here); Reference Classes ship
# with the methods package.
library(R6)

Shelf <- R6Class("Shelf", # nolint: object_name_linter.
  public = list(
    titles = character(),
    add = function(title) {
      self$titles <- c(self$titles, title)
      invisible(self)
    },
    count = function() length(self$titles)
  )
)

main_shelf <- Shelf$new()
same_shelf <- main_shelf
main_shelf$add("Paper Moons")$add("Loud Roofs")
same_shelf$count()
#> [1] 2
identical(main_shelf, same_shelf)
#> [1] TRUE

# clone() is how an R6 object is copied on purpose.
annex_shelf <- main_shelf$clone()
annex_shelf$add("Ten Winters")
c(main = main_shelf$count(), annex = annex_shelf$count())
#>  main annex
#>     2     3

# The method call above changed main_shelf without an assignment, which is
# the sign of reference semantics: a function can do the same.
add_title <- function(shelf, title) {
  shelf$add(title)
  invisible(NULL)
}
add_title(main_shelf, "Notes on Gravity")
main_shelf$count()
#> [1] 3

# Reference Classes: fields live in the object's environment, "<<-" assigns
# to a field inside a method, and copy() makes a duplicate.
Desk <- setRefClass("Desk", # nolint: object_name_linter.
  fields = list(returns = "integer"),
  methods = list(
    log_return = function() {
      returns <<- returns + 1L # nolint: assignment_linter.
      invisible(.self)
    }
  )
)
front <- Desk$new(returns = 0L)
alias <- front
alias$log_return()
front$returns
#> [1] 1
back <- front$copy()
back$log_return()
c(front = front$returns, back = back$returns)
#> front  back
#>     1     2

source("scenario.R")

# rm() removes the binding, not necessarily the object: the value is freed
# only when no other name (and nothing else) refers to it.
scratch_a <- 1:3
scratch_b <- scratch_a
rm(scratch_a)
exists("scratch_a")
#> [1] FALSE
scratch_b
#> [1] 1 2 3

# Several names, strings, or a character vector in list = ...
tmp_one <- 1
tmp_two <- 2
tmp_three <- 3
rm("tmp_one", tmp_two)
rm(list = c("tmp_three"))
exists("tmp_one") || exists("tmp_two") || exists("tmp_three")
#> [1] FALSE

# ... and a pattern, with ls(), when a family of names is cleaned up.
tmp_a <- tmp_b <- tmp_c <- 0
rm(list = ls(pattern = "^tmp_"))
ls(pattern = "^tmp_")
#> character(0)

# A name that does not exist gives a warning, not an error.
rm_outcome <- tryCatch(
  rm(no_such_object),
  warning = function(w) conditionMessage(w)
)
rm_outcome
#> [1] "object 'no_such_object' not found"

# Passing a character vector in ... removes the vector, not the objects it
# names; list = is the argument that does that.
doomed <- c("kept_one", "kept_two")
kept_one <- 1
kept_two <- 2
rm(doomed)
exists("doomed")
#> [1] FALSE
exists("kept_one")
#> [1] TRUE
doomed <- c("kept_one", "kept_two")
rm(list = doomed)
exists("kept_one")
#> [1] FALSE

# rm() acts on the current environment, which inside a function is the
# function's frame. Other environments need envir.
forget_title <- function() {
  title <- "Ten Winters"
  rm(title)
  exists("title", inherits = FALSE)
}
forget_title()
#> [1] FALSE
bin <- new.env()
assign("old_loan", "L001", envir = bin)
rm("old_loan", envir = bin)
ls(bin)
#> character(0)

# Locked environments cannot lose bindings.
tryCatch(rm("sum", envir = baseenv()), error = conditionMessage)
#> [1] "cannot remove variables from the base environment"

# The workspace-clearing idiom of R FAQ 7.3. Without all.names = TRUE the
# names that start with a dot survive. It neither unloads packages nor resets
# options, and it is best kept out of scripts and packages.
.hidden_note <- "starts with a dot"
rm(list = ls())
exists("books")
#> [1] FALSE
exists(".hidden_note")
#> [1] TRUE
rm(list = ls(all.names = TRUE))
exists(".hidden_note")
#> [1] FALSE

source("scenario.R")

# local() evaluates its expression in a new environment, so the temporary
# names it creates never reach the workspace.
overdue_returned <- local({
  returned <- loans[!is.na(loans$return_date), ]
  days_out <- as.integer(returned$return_date - returned$loan_date)
  sum(days_out > loan_days, na.rm = TRUE)
})
overdue_returned
#> [1] 25
exists("returned")
#> [1] FALSE
exists("days_out")
#> [1] FALSE

# Without local(), the same steps leave their helpers behind.
returned <- loans[!is.na(loans$return_date), ]
exists("returned")
#> [1] TRUE
rm(returned)

# local() is eval() in a fresh environment, nothing more.
direct <- eval(quote({
  a_name <- 6L
  a_name * 7L
}), new.env())
via_local <- local({
  a_name <- 6L
  a_name * 7L
})
identical(direct, via_local)
#> [1] TRUE
exists("a_name")
#> [1] FALSE

# The envir argument chooses where the names go instead of a new environment.
desk <- new.env()
local({
  opened <- "09:00"
  closed <- "17:30"
}, envir = desk)
sort(ls(desk))
#> [1] "closed" "opened"

# A function created inside local() keeps the local names alive: private
# state without a global variable.
next_loan_id <- local({
  last <- 60L
  function() {
    last <<- last + 1L # nolint: assignment_linter.
    sprintf("L%03d", last)
  }
})
next_loan_id()
#> [1] "L061"
next_loan_id()
#> [1] "L062"
exists("last")
#> [1] FALSE

# "<<-" inside local() skips the local environment and looks further out.
counter <- 0L
local({
  counter <- 100L
  counter <<- counter + 1L # nolint: assignment_linter.
})
counter
#> [1] 101

source("scenario.R")

# Report the message of an error (or "no error") for a piece of code.
outcome <- function(code) {
  tryCatch(
    {
      code
      "no error"
    },
    error = conditionMessage
  )
}

# lockBinding() turns a name into a constant.
bindingIsLocked("shelf_today", globalenv())
#> [1] FALSE
lockBinding("shelf_today", globalenv())
bindingIsLocked("shelf_today", globalenv())
#> [1] TRUE
outcome(shelf_today <- as.Date("2026-07-01"))
#> [1] "cannot change value of locked binding for 'shelf_today'"
shelf_today
#> [1] "2026-06-30"
unlockBinding("shelf_today", globalenv())
shelf_today <- as.Date("2026-06-30")
bindingIsLocked("shelf_today", globalenv())
#> [1] FALSE

# A locked binding refuses every form of change: assign(), "<<-", $<-, and
# complex assignment.
lockBinding("loan_days", globalenv())
outcome(assign("loan_days", 14L))
#> [1] "cannot change value of locked binding for 'loan_days'"
outcome(local(loan_days <<- 14L))
#> [1] "cannot change value of locked binding for 'loan_days'"
outcome(loan_days[[1L]] <- 14L)
#> [1] "cannot change value of locked binding for 'loan_days'"
rm("loan_days")
exists("loan_days")
#> [1] FALSE
loan_days <- 21L

# The binding is locked, not the value: an environment stored in it can still
# be modified, but "registry$entries <- 1L" is a complex assignment that
# assigns the result back to the name registry, so it is refused as well.
registry <- new.env()
lockBinding("registry", globalenv())
outcome(registry$entries <- 1L)
#> [1] "cannot change value of locked binding for 'registry'"
assign("entries", 1L, envir = registry)
get("entries", envir = registry)
#> [1] 1
outcome(registry <- new.env())
#> [1] "cannot change value of locked binding for 'registry'"

# lockEnvironment() stops names being added or removed; bindings = TRUE locks
# every existing binding too.
settings <- new.env()
settings$colour <- "green"
lockEnvironment(settings)
environmentIsLocked(settings)
#> [1] TRUE
settings$colour <- "blue"
outcome(settings$size <- "large")
#> [1] "cannot add bindings to a locked environment"
outcome(rm("colour", envir = settings))
#> [1] "cannot remove bindings from a locked environment"
lockEnvironment(settings, bindings = TRUE)
outcome(settings$colour <- "red")
#> [1] "cannot change value of locked binding for 'colour'"
settings$colour
#> [1] "blue"

# Assigning to a name that base R defines does not touch base R: it creates a
# new binding in the global environment that masks it.
pi <- 3
pi
#> [1] 3
base::pi
#> [1] 3.141593
rm(pi)
pi
#> [1] 3.141593

# The base and stats namespaces are locked when they are loaded.
outcome(assign("sum", 0, envir = baseenv()))
#> [1] "cannot change value of locked binding for 'sum'"
outcome(assign("lm", 0, envir = asNamespace("stats")))
#> [1] "cannot change value of locked binding for 'lm'"
environmentIsLocked(asNamespace("stats"))
#> [1] TRUE
environmentIsLocked(globalenv())
#> [1] FALSE

# Locking a name that does not exist is an error.
outcome(lockBinding("not_there", globalenv()))
#> [1] "no binding for \"not_there\""

source("scenario.R")

outcome <- function(code) {
  tryCatch(
    {
      code
      "no error"
    },
    error = conditionMessage
  )
}

# An active binding is a name whose value is computed by a function every time
# the name is read: a variable that cannot go stale.
makeActiveBinding(
  "outstanding",
  function() sum(is.na(loans$return_date)),
  globalenv()
)
bindingIsActive("outstanding", globalenv())
#> [1] TRUE
outstanding
#> [1] 7
loans$return_date[loans$loan_id == "L054"] <- shelf_today
outstanding
#> [1] 6

# The function behind the name can be retrieved (R 4.0.0).
body(activeBindingFunction("outstanding", globalenv()))
#> sum(is.na(loans$return_date))

# A function of one argument also handles assignment: here a setting that
# checks the new value before it is accepted.
make_limit <- function(initial) {
  value <- initial
  function(new) {
    if (missing(new)) {
      return(value)
    }
    stopifnot(is.numeric(new), length(new) == 1L, new > 0)
    value <<- as.integer(new) # nolint: assignment_linter.
    invisible(value)
  }
}
makeActiveBinding("loan_limit", make_limit(3L), globalenv())
loan_limit
#> [1] 3
loan_limit <- 5
loan_limit
#> [1] 5
outcome(loan_limit <- -1)
#> [1] "new > 0 is not TRUE"
outcome(loan_limit <- "many")
#> [1] "is.numeric(new) is not TRUE"
loan_limit
#> [1] 5

# The function is called with no arguments to read and with one to write; a
# function that takes none cannot be assigned to.
makeActiveBinding("always_21", function() 21L, globalenv())
outcome(always_21 <- 14L)
#> [1] "unused argument (base::quote(14))"

# An active binding cannot replace an ordinary one, and each read runs the
# function again, including its side effects.
shelf_name <- "Main hall"
outcome(makeActiveBinding("shelf_name", function() "Annex", globalenv()))
#> [1] "symbol already has a regular binding"
reads <- 0L
makeActiveBinding(
  "read_count",
  function() {
    reads <<- reads + 1L # nolint: assignment_linter.
    reads
  },
  globalenv()
)
c(read_count, read_count, read_count)
#> [1] 1 2 3

# Complex assignment on an active binding reads the value, modifies a copy and
# writes the result back through the function, which here refuses a vector of
# length two.
makeActiveBinding("stock_view", make_limit(10L), globalenv())
outcome(stock_view[[2L]] <- 1)
#> [1] "length(new) == 1L is not TRUE"
stock_view
#> [1] 10

# The messages of this page, collected: each snippet runs in its own scratch
# environment, and the condition it signals is printed.
report <- function(code) {
  sandbox <- new.env()
  sandbox$stock <- c(main = 4L, annex = 2L)
  sandbox$locked <- 1
  lockBinding("locked", sandbox)
  frozen <- new.env()
  lockEnvironment(frozen)
  sandbox$frozen <- frozen
  result <- tryCatch(
    {
      eval(parse(text = code), sandbox)
      "no condition"
    },
    error = function(e) paste("error:", conditionMessage(e)),
    warning = function(w) paste("warning:", conditionMessage(w))
  )
  cat(code, "\n    ", result, "\n", sep = "")
}

snippets <- c(
  "5 <- 3",
  "NULL <- 3",
  "if (flag = TRUE) 1",
  "stock <- stock2 = 3",
  "no_such_object",
  "no_such_object[[1L]] <- 1",
  "names(no_such_object) <- 'a'",
  "shape(stock) <- 2",
  "get('no_such_object')",
  "get('stock', mode = 'function')",
  "get(c('stock', 'locked'))",
  "assign(c('a', 'b'), 1)",
  "mget('no_such_object')",
  "rm(no_such_object)",
  "locked <- 2",
  "frozen$x <- 1",
  "rm('stock', envir = frozen)",
  "assign('x', 1, envir = baseenv())",
  "rm('sum', envir = baseenv())",
  "lockBinding('no_such_object', environment())",
  "makeActiveBinding('stock', function() 1, environment())",
  "tracemem(sum)",
  "tracemem(NULL)",
  "tracemem(new.env())"
)
for (snippet in snippets) {
  report(snippet)
}
#> 5 <- 3
#>     error: invalid (do_set) left-hand side to assignment
#> NULL <- 3
#>     error: invalid (do_set) left-hand side to assignment
#> if (flag = TRUE) 1
#>     error: <text>:1:10: unexpected '='
#> 1: if (flag =
#>              ^
#> stock <- stock2 = 3
#>     error: could not find function "<-<-"
#> no_such_object
#>     error: object 'no_such_object' not found
#> no_such_object[[1L]] <- 1
#>     error: object 'no_such_object' not found
#> names(no_such_object) <- 'a'
#>     error: object 'no_such_object' not found
#> shape(stock) <- 2
#>     error: could not find function "shape<-"
#> get('no_such_object')
#>     error: object 'no_such_object' not found
#> get('stock', mode = 'function')
#>     error: object 'stock' of mode 'function' was not found
#> get(c('stock', 'locked'))
#>     error: first argument has length > 1
#> assign(c('a', 'b'), 1)
#>     warning: only the first element is used as variable name
#> mget('no_such_object')
#>     error: value for ‘no_such_object’ not found
#> rm(no_such_object)
#>     warning: object 'no_such_object' not found
#> locked <- 2
#>     error: cannot change value of locked binding for 'locked'
#> frozen$x <- 1
#>     error: cannot add bindings to a locked environment
#> rm('stock', envir = frozen)
#>     error: cannot remove bindings from a locked environment
#> assign('x', 1, envir = baseenv())
#>     error: cannot add binding of 'x' to the base environment
#> rm('sum', envir = baseenv())
#>     error: cannot remove variables from the base environment
#> lockBinding('no_such_object', environment())
#>     error: no binding for "no_such_object"
#> makeActiveBinding('stock', function() 1, environment())
#>     error: symbol already has a regular binding
#> tracemem(sum)
#>     error: argument must not be a function
#> tracemem(NULL)
#>     error: cannot trace NULL
#> tracemem(new.env())
#>     error: 'tracemem' is not useful for promise and environment objects