Lexical scoping, also known as static binding, determines how a value binds to a free variable in a function. This is a key feature that originated from the scheme functional programming language, and it makes R different from S. In the following recipe, we will show you how lexical scoping works in R.
Perform the following steps to understand how the scoping rule works:
First, we create an
xvariable, and we then create atmpfuncfunction withx+3as the return:>x<- 5 >tmpfunc<- function(){ + x + 3 + } >tmpfunc() [1] 8
We then create a function named
parentfuncwith achildfuncnested function and see what returns when we call theparentfuncfunction:>x<- 5 >parentfunc<- function(){ + x<- 3 + childfunc<- function(){ + x + } + childfunc() + } >parentfunc() [1] 3
Next, we create an
xstring, and then we create alocalassignfunction to modifyxwithin the function:> x <- 'string' >localassign<- function(x){ + x <- 5 + x + } >localassign(x) [1] 5 >x [1] "string"
We can also create another
globalassignfunction but reassign thexvariable to5using the<<-notation:> x <- 'string' >gobalassign<- function(x){ + x <<- 5 + x + } >gobalassign(x) [1] 5 >x [1] 5
There are two different types of variable binding methods: one is lexical binding, and the other is dynamic binding. Lexical binding is also called static binding in which every binding scope manages variable names and values in the lexical environment. That is, if a variable is lexically bound, it will search the binding of the nearest lexical environment. In contrast to this, dynamic binding keeps all variables and values in the global state. That is, if a variable is dynamically bound, it will bind to the most recently created variable.
To demonstrate how lexical binding works, we first create an x variable and assign 5 to x in the global environment. Then, we can create a function named tmpfunc. The function outputs x + 3 as the return value. Even though we do not assign any value to x within the tmpfunc function, x can still find the value of x as 5 in the global environment.
Next, we create another function named parentfunc. In this function, we assign x to 3 and create a childfunc nested function (a function defined within a function). At the bottom of the parentfunc body, we invoke childfunc as the function return. Here, we find that the function uses the x defined in parentfunc instead of the one defined outside parentfunc. This is because R searches the global environment for a matched symbol name, and then subsequently searches the namespace of packages on the search list.
Moving on, let's take a look at what will return if we create an x variable as a string in the global state and assign an x local variable to 5 within the function. When we invoke the localassign function, we discover that the function returns 5 instead of the string value. On the other hand, if we print out the value of x, we still see string in return. While the local variable and global variable have the same name, the assignment of the function does not alter the value of x in global state. If you need to revise the value of x in the global state, you can use the <<- notation instead.