DS Scope Study Guide

Scoping rules of r In R, scoping rules determine how variables are looked up and how functions access their arguments or variables within different environments. There are two main types of scoping in R: lexical scoping (also called static scoping) and dynamic scoping. Here’s a breakdown of the scoping rules in R: 1. Lexical Scoping (Static Scoping) R primarily uses lexical scoping, which means that the value of a variable is determined by its environment at the time the function is created (when it is defined), not when the function is executed. When a function is called, R looks for variables in the local environment (inside the function) first. If the variable is not found there, R will then look for it in the environment where the function was defined (the enclosing environment). If it is not found there, it will continue searching in the global environment and, ultimately, in the base environment. For example: x <- 10 f <- function() { print(x). # This will refer to x in the environment where f is defined. } f() # Will print 10, because x is found in the global environment. In the example above, even though the function f() is called in the global environment, it uses the value of x from the global environment due to lexical scoping. 2. Dynamic Scoping (Less Common in R) While R mostly uses lexical scoping, dynamic scoping can still come into play in certain contexts, such as in the case of non-standard evaluation (NSE). Dynamic scoping means that when a variable is used inside a function, R will search for the variable in the environment where the function is called, not where it was defined. 3. Environments in R In R, an environment is a collection of bindings between variable names and their values. Environments have a hierarchical structure, where a function environment can have parent environments. This forms a chain of environments R will search when resolving variable names. The order of the search is: 1. The local environment (where the function is called) 2. The parent environment (where the function was defined) 3. The global environment 4. The base environment (which is at the top of the search chain) 4. Scope of Arguments In R, when you pass arguments to a function, the values of the arguments are evaluated in the environment of the function call. However, the function has its own local scope for these arguments. This means that changes to the arguments within the function do not affect the original variables outside the function (unless they are modified through techniques like <<-). For example: x <- 5 f <- function(y) { y <- y + 1 print(y) } f(x) print(x) # This changes y only within the function # Prints 6 # Prints 5, x is unchanged outside the function 5. The <<- Operator R allows for modification of variables in parent environments using the <<- operator. This operator allows you to assign a value to a variable in an outer environment (outside the local function scope). However, it’s generally advised to avoid using <<- due to potential confusion and unintended consequences. For example: x <- 5 f <- function() { x <<- 10 } f() print(x) # Modifies x in the global environment # Prints 10, because x was modified globally 6. Closures A closure in R is a function that captures the environment in which it was created. This means a closure remembers the variables from its defining environment, even when the function is called in a different environment. make_adder <- function(a) { return(function(b) { return(a + b) }) } add_five <- make_adder(5) add_five(3) # Returns 8, because 'a' is captured in the closure