<aside> 💡 Local definitions (written in the format (local [<defintions>] <expressions>)) should be used whenever…

1. multiple functions need to be encapsulated into a new function
2. a recursive function needs to compute the same thing more than once.

Forming local definitions is a 3-step process —

1. renaming local objects wherever they are referenced in the local expression
2. lifting local object definitions into the global scope
3. replacing the local function by its body (i.e. its trampoline functions)

Locally-defined objects have a restricted scope and are typically inaccessible to objects in the global scope.

</aside>

Forming and Intuition

• Local expressions are self-contained expressions whose definitions are not defined in the global scope.

• For instance,

  (define a 1)
  (define b 2)
  
  (local [(define a 3)
  				(define b 4)]
  	(+ a b))
  
  (+ a b)
  
  ;; (+ a b) in the local expression returns 7 (a = 3, b, 4).
  ;; (+ a b) in the global scope returns 3 (a = 1, b = 2).
  

Lexical Scoping

<aside> 🔍 Another discussion of lexical scoping through University of Washington’s Programming Languages course can be found here.

</aside>

• With lexical scoping, the compiler searches the local function in question before searching the scope where the local function was defined and so on.
• In the example shown below, we start searching for a and b from the local expression (black box that locally defines b).
  • In the local expression, b is defined as 3 while a is undefined. As such, the compiler searches for a in the scope where the local expression was defined — the global scope.
  • In the global scope, a is defined as 1. Therefore, the local function (+ a b) evaluates to 4 since it takes the local definition of b (3)and the global definition of a (1).
  • For the global expression (+ a (local [(define b 3)] (+ a b)) b), however, the global definitions of a (1) and b(2) are used. Therefore, the expression evaluates to (+ 1 4 2) = 7.