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

Need a 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
}

Need a 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

Need a 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

Need a hint?

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