Variable scope (lexical scoping) in R Programming - Step-by-Step Execution

Concept Flow - Variable scope (lexical scoping)

Start: Global environment

↓

Define function

↓

Call function

↓

Look for variable in function environment

↓

Found?

↓

Use variable

↓

Return value or error if not found

↓

End

When a function runs, it first looks for variables inside itself. If not found, it looks outside in the environment where it was created, following the chain until found or error.

Execution Sample

R Programming

x <- 10
f <- function() {
  x <- 5
  x
}
f()

Defines x globally as 10, then a function f that has its own x as 5 and returns it. Calling f() returns 5, showing function uses its own x.

Execution Table

Step	Action	Environment	Variable looked up	Value found	Note
1	Assign x <- 10	Global	x	10	Global variable x set to 10
2	Define function f	Global	-	-	Function f created, enclosing environment is Global
3	Call f()	Global -> f	-	-	Function f starts execution
4	Inside f: assign x <- 5	f	x	5	Local variable x set to 5 inside f
5	Inside f: return x	f	x	5	x found locally in f, value 5 returned
6	f() returns	Global	-	5	Function call ends, returns 5

💡 Function f returns local x = 5; global x = 10 is not used inside f

Variable Tracker

Variable	Global Start	After f() call	Inside f after assignment	After f() returns
x	10	10	5 (local in f)	10

Key Moments - 3 Insights

Why does f() return 5 and not 10?

Because inside f(), x is assigned locally to 5 (see execution_table step 4). The function uses its local x, not the global one.

What happens if x is not defined inside f()?

The function looks in the parent environment (global) for x (see concept_flow). If found, it uses that value; otherwise, it gives an error.

Is the global x changed when f() runs?

No, the global x remains 10 (see variable_tracker). The local x inside f() is separate and temporary.

Visual Quiz - 3 Questions

Look at the execution_table step 5. What value of x does f() use to return?

A 10

B 5

C Undefined

D 15

💡 Hint

Check the 'Value found' column at step 5 in execution_table.

At which step does the local variable x get assigned inside the function?

A Step 2

B Step 3

C Step 4

D Step 6

💡 Hint

Look for 'assign x <- 5' in the Action column of execution_table.

If the line 'x <- 5' inside f() was removed, what value would f() return?

A 10

B Error

C 5

D NULL

💡 Hint

Refer to concept_flow: function looks in parent environment if variable not found locally.

Concept Snapshot

Variable scope in R uses lexical scoping.
Functions first look for variables inside themselves.
If not found, they look in the environment where they were created.
Local variables override global ones with the same name.
Global variables remain unchanged by function local assignments.

Full Transcript

This visual trace shows how R uses lexical scoping for variables. We start with a global variable x set to 10. Then we define a function f that assigns x to 5 locally and returns x. When we call f(), it uses the local x inside the function, returning 5, not the global 10. The function looks for variables first inside itself, then outside in the global environment if needed. The global x remains unchanged after calling f(). This helps understand how R finds and uses variables during function execution.

Practice

1. What does lexical scoping mean in R programming?

easy

A. Variables are looked up where the function is defined, not where it is called.

B. Variables are always global and accessible everywhere.

C. Variables inside functions overwrite global variables automatically.

D. Variables are found only inside loops.

Solution

1. Step 1: Understand lexical scoping definition

   Lexical scoping means R looks for variables in the environment where the function was written, not where it is called.

2. Step 2: Compare options with definition

   Only Variables are looked up where the function is defined, not where it is called. correctly describes this behavior; others are incorrect or unrelated.

3. Final Answer:

   Variables are looked up where the function is defined, not where it is called. -> Option A

4. Quick Check:

   Lexical scoping = lookup where defined [OK]

Hint: Remember: R finds variables where code is written, not run [OK]

Common Mistakes:

• Thinking variables are always global
• Confusing lexical with dynamic scoping
• Assuming function variables overwrite globals automatically

2. Which of the following is the correct way to define a local variable x inside a function in R?

easy

A. global x = 5

B. x <- 5 inside the function body

C. var x = 5

D. x := 5

Solution

1. Step 1: Recall R syntax for variable assignment

   In R, variables are assigned using the arrow operator (<-), especially inside functions.

2. Step 2: Check each option

   x <- 5 inside the function body uses correct R syntax. Options B, C, and D use syntax from other languages or invalid forms.

3. Final Answer:

   x <- 5 inside the function body -> Option B

4. Quick Check:

   Use <- for assignment in R [OK]

Hint: Use <- to assign variables inside functions in R [OK]

Common Mistakes:

• Using global or var keywords (not R syntax)
• Using := which is not valid in base R
• Confusing R with other languages like JavaScript or Python

3. What is the output of this R code?

y <- 10
f <- function() {
  y <- 5
  return(y)
}
f()

medium

A. 10

B. NULL

C. 5

D. Error

Solution

1. Step 1: Identify variable scopes

   Global y is 10, but inside function f, y is locally assigned 5.

2. Step 2: Determine returned value

   The function returns the local y, which is 5, not the global y.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Local variable y inside function = 5 [OK]

Hint: Inside function, local variables override globals [OK]

Common Mistakes:

• Assuming function returns global y (10)
• Thinking function returns NULL by default
• Expecting an error due to variable shadowing

4. Consider this R code:

z <- 3
f <- function() {
  z <- z + 1
  return(z)
}
f()

What is the result?

medium

A. 4

B. 3

C. NULL

D. Error: object 'z' not found

Solution

1. Step 1: Analyze variable usage inside function

   Inside f, z <- z + 1 tries to read local z before assignment, but local z doesn't exist yet.

2. Step 2: Understand lexical scoping rules

   R looks for z in local scope first; it is not found, so it does not use global z for the right side in assignment.

3. Step 3: Resulting error

   This causes an error: object 'z' not found.

4. Final Answer:

   Error: object 'z' not found -> Option D

5. Quick Check:

   Local variable used before assignment causes error [OK]

Hint: Local vars must exist before use; else error occurs [OK]

Common Mistakes:

• Assuming global z is used automatically
• Expecting output 4 without error
• Ignoring variable initialization order

5. Given the code below, what will g() return?

a <- 2
f <- function() {
  a <- 3
  h <- function() {
    a <- 4
    return(a)
  }
  return(h())
}
g <- function() {
  return(f())
}
g()

hard

A. 4

B. 3

C. Error

D. 2

Solution

1. Step 1: Trace nested function variable scopes

   Global a = 2, f() sets local a = 3, h() inside f sets local a = 4.

2. Step 2: Determine return value of g()

   g() calls f(), which calls h(), which returns its local a = 4.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Innermost local variable a = 4 returned [OK]

Hint: Innermost function's local variable shadows outer ones [OK]

Common Mistakes:

• Returning outer function's a (3) instead of inner (4)
• Returning global a (2)
• Expecting an error due to nested functions