Environment and closures in R Programming - Step-by-Step Execution

Concept Flow - Environment and closures

Define function with free variables

↓

Function remembers environment

↓

Call function

↓

Look up variables in saved environment

↓

Execute function body using saved variables

↓

Return result

A closure is a function that remembers the environment where it was created, so it can access variables even after that environment is gone.

Execution Sample

R Programming

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

This code creates a counter function that remembers and updates a variable 'count' each time it is called.

Execution Table

Step	Action	Environment State	Variable 'count'	Output
1	Call make_counter()	Create new environment for make_counter	count = 0	Function returned (closure)
2	Assign returned function to 'counter'	Closure remembers environment with count=0	count = 0	No output
3	Call counter()	Use saved environment	count = 0 -> count = 1	1
4	Call counter() again	Use saved environment	count = 1 -> count = 2	2
5	Call counter() again	Use saved environment	count = 2 -> count = 3	3

💡 Execution stops after calls to counter() show count increasing, demonstrating closure remembers state.

Variable Tracker

Variable	Start	After call 1	After call 2	After call 3
count	0	1	2	3

Key Moments - 2 Insights

Why does 'count' keep its value between calls to 'counter()'?

Because 'counter' is a closure that remembers the environment where 'count' was defined, so it updates the same 'count' variable each time (see execution_table steps 3-5).

What does the '<<-' operator do in the function?

It updates the 'count' variable in the parent environment of the function, not a new local variable, allowing the closure to modify 'count' (see execution_table step 3).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of 'count' after calling counter() the first time?

A NA

B 1

C 0

D Function itself

💡 Hint

Check the 'Variable count' column at step 3 in the execution_table.

At which step does the 'count' variable become 2?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Variable count' column in the execution_table rows.

If we remove '<<-' and use '<-' inside the inner function, what happens to 'count'?

A 'count' becomes local and does not update parent

B 'count' in parent environment updates

C Error occurs

D Function stops working

💡 Hint

Recall that '<<-' updates parent environment variables, '<-' creates local variables (see key_moments question 2).

Concept Snapshot

Environment and closures in R:
- Functions remember the environment where they were created.
- Closures can access and modify variables from that environment.
- Use '<<-' to update variables in the parent environment.
- This allows functions to keep state between calls.

Full Transcript

This example shows how R functions can remember variables from their creation environment, called closures. The make_counter function creates a variable 'count' and returns a function that increases 'count' each time it is called. The returned function remembers 'count' even after make_counter finishes. The '<<-' operator updates 'count' in the saved environment, so the value persists between calls. This is why calling counter() repeatedly increases 'count' from 0 to 1, then 2, then 3. Closures let functions keep state, like a counter, by saving their environment.

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