Environment and closures in R Programming - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an environment in R?

An environment in R is like a box that stores variables and their values. It keeps track of where to find variables when you use them in your code.

beginner

What is a closure in R?

A closure is a function that remembers the environment where it was created. It can use variables from that environment even after the environment is no longer active.

intermediate

How does R find a variable inside nested functions?

R looks for the variable in the current environment first. If it is not found, it checks the parent environment, and keeps going up until it finds the variable or reaches the empty environment.

intermediate

Explain why closures are useful with an example.

Closures let you create functions that keep some data inside. For example, a function that adds a fixed number to its input can remember that number inside its environment.

advanced

What happens if you change a variable inside a closure's environment?

Changing a variable inside a closure's environment updates the stored value. The closure will use the new value the next time it runs.

What does an environment in R store?

A Only numbers

B Only functions

C Variables and their values

D Only text strings

An environment stores variables and their values so R knows where to find them.

What is a closure in R?

A A special kind of loop

B A type of variable

C A data frame

D A function that remembers its environment

A closure is a function that keeps access to the environment where it was created.

If a variable is not found in the current environment, where does R look next?

A Random environment

B Parent environment

C Global environment only

D It stops searching

R searches the parent environment next, moving up until it finds the variable or reaches the global environment.

Why are closures useful?

A They keep data inside functions for later use

B They speed up code execution

C They delete variables automatically

D They create new environments

Closures keep data inside functions, allowing the function to remember values between calls.

What happens when you change a variable inside a closure's environment?

A The closure uses the updated value next time

B The closure breaks

C The variable resets to original

D Nothing changes

Changing the variable updates the stored value, so the closure uses the new value.

Describe what an environment is in R and how it helps with variable lookup.

Think of it as a box where R keeps your variables.

Explain closures in R and why they are useful with a simple example.

Imagine a function that remembers a secret number to add.

Practice

1. What is an environment in R programming?

easy

A. A type of loop for repeating code

B. A place where variables and their values are stored

C. A function that takes another function as input

D. A package that extends R's capabilities

Solution

1. Step 1: Understand the definition of environment

   In R, an environment is a collection where variables and their values are stored together.

2. Step 2: Differentiate from other options

   Options B, C, and D describe loops, higher-order functions, and packages, which are not environments.

3. Final Answer:

   A place where variables and their values are stored -> Option B

4. Quick Check:

   Environment = variable storage [OK]

Hint: Remember: environment stores variables like a box [OK]

Common Mistakes:

• Confusing environment with a function
• Thinking environment is a loop
• Mixing environment with packages

2. Which of the following is the correct way to create a closure in R?

easy

A. f <- function(x) { function() x + 1 }

B. f <- function(x) { x + 1 }

C. f <- function(x) { x <- x + 1 }

D. f <- function(x) { print(x) }

Solution

1. Step 1: Identify closure structure

   A closure is a function that returns another function which remembers variables from its environment.

2. Step 2: Check each option

   f <- function(x) { function() x + 1 } returns a function that uses 'x' from the outer function, creating a closure. Others do not return a function.

3. Final Answer:

   f <- function(x) { function() x + 1 } -> Option A

4. Quick Check:

   Closure returns function using outer variable [OK]

Hint: Closure = function returning function using outer variables [OK]

Common Mistakes:

• Not returning a function inside another function
• Modifying variable without returning a function
• Confusing print with returning a function

3. What will be the output of the following R code?

make_counter <- function() {
  count <- 0
  function() {
    count <<- count + 1
    count
  }
}
counter <- make_counter()
counter()
counter()

medium

A. Error due to undefined variable

B. [1] 0 followed by [1] 1

C. [1] 1 followed by [1] 1

D. [1] 1 followed by [1] 2

Solution

1. Step 1: Understand the closure and <<- operator

   The inner function modifies 'count' in the parent environment using <<- and increments it by 1 each call.

2. Step 2: Trace the calls to counter()

   First call returns 1 (0+1), second call returns 2 (1+1).

3. Final Answer:

   [1] 1 followed by [1] 2 -> Option D

4. Quick Check:

   Closure increments count with <<- [OK]

Hint: <<- changes outer variable, so count increases each call [OK]

Common Mistakes:

• Thinking count resets each call
• Confusing <- with <<- operator
• Expecting error due to variable scope

4. Identify the error in this R code that tries to create a closure:

make_adder <- function(x) {
  function(y) {
    x + y
  }
}
add5 <- make_adder(5)
add5(3)
rm(x)

medium

A. The function make_adder is missing a return statement

B. Removing 'x' breaks the closure, causing an error on add5(3)

C. No error; code runs fine

D. The inner function should use <<- to modify x

Solution

1. Step 1: Understand closure variable dependency

   The inner function depends on 'x' stored in its own dedicated environment created by make_adder.

2. Step 2: Effect of removing 'x'

   rm(x) removes 'x' from the global environment if it exists, but the closure's environment retains its own 'x' = 5, so add5(3) works fine.

3. Final Answer:

   No error; code runs fine -> Option C

4. Quick Check:

   Closure environments are independent of global [OK]

Hint: rm(x) doesn't affect closure's private x [OK]

Common Mistakes:

• Thinking functions need explicit return
• Believing <<- is needed to read outer variables
• Mistakenly thinking rm(x) removes closure's x

5. You want to create a function in R that remembers a secret number and returns a function to check guesses. Which approach correctly uses closures to keep the secret safe?

hard

A. secret_keeper <- function(secret) { function(guess) { guess == secret } }

B. secret_keeper <- function(secret) { secret <- NULL; function(guess) { guess == secret } }

C. secret_keeper <- function(secret) { function(guess) { secret <- guess; TRUE } }

D. secret_keeper <- function(secret) { function(guess) { print(secret); guess } }

Solution

1. Step 1: Identify closure usage to keep secret

   secret_keeper <- function(secret) { function(guess) { guess == secret } } returns a function that compares guess to secret stored in the closure environment, keeping secret safe.

2. Step 2: Analyze other options for flaws

   secret_keeper <- function(secret) { secret <- NULL; function(guess) { guess == secret } } sets secret to NULL, losing the secret. secret_keeper <- function(secret) { function(guess) { secret <- guess; TRUE } } changes secret to guess, breaking secrecy. secret_keeper <- function(secret) { function(guess) { print(secret); guess } } prints secret, exposing it.

3. Final Answer:

   secret_keeper <- function(secret) { function(guess) { guess == secret } } -> Option A

4. Quick Check:

   Closure keeps secret hidden and accessible only inside [OK]

Hint: Closure hides secret; don't overwrite or expose it [OK]

Common Mistakes:

• Overwriting secret variable inside closure
• Exposing secret with print statements
• Setting secret to NULL before use