Environment and closures in R Programming - Mini Project: Build & Apply

Understanding Environment and Closures in R

📖 Scenario: Imagine you are creating a simple counter tool in R that remembers its count even after you use it multiple times. This helps you understand how R keeps track of variables inside functions using environments and closures.

🎯 Goal: You will build a function that creates a counter. Each time you call the counter, it will increase its count by 1 and remember the new count. This shows how closures keep data safe inside functions.

📋 What You'll Learn

Create a function called make_counter that returns another function.

Inside make_counter, create a variable count set to 0.

The returned function should add 1 to count each time it is called and return the updated count.

Print the result of calling the counter function multiple times.

💡 Why This Matters

🌍 Real World

Closures are used in R to keep data safe inside functions, like counters, calculators, or settings that remember user choices.

💼 Career

Understanding environments and closures helps in writing clean, efficient R code for data analysis, package development, and building interactive tools.

1

Create the make_counter function with a count variable

Write a function called make_counter that creates a variable count and sets it to 0 inside the function.

R Programming

# Define the function make_counter and create count variable
# Your code here

Hint

Use function() to create make_counter and inside it write count <- 0.

2

Return a function that increases count by 1

Inside make_counter, return a function that adds 1 to count and returns the new value of count.

R Programming

make_counter <- function() {
  count <- 0
  # Return a function that adds 1 to count and returns count
  # Your code here
}

Hint

Use function() inside make_counter and update count with <<- to change the variable in the parent environment.

3

Create a counter instance and call it multiple times

Create a variable counter by calling make_counter(). Then call counter() three times, storing each result in result1, result2, and result3.

R Programming

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

# Create counter and call it three times
# Your code here

Hint

Call make_counter() and save it as counter. Then call counter() three times and save results.

4

Print the results to see the counter values

Print result1, result2, and result3 each on its own line to show the counter increasing.

R Programming

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

counter <- make_counter()
result1 <- counter()
result2 <- counter()
result3 <- counter()

# Print the results
# Your code here

Hint

Use print() to show each result on its own line.

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