Non-local variable

In programming language theory, a non-local variable is a variable that is not defined in the local scope. While the term can refer to global variables, it is primarily used in the context of nested and anonymous functions where some variables can be neither in the local nor the global scope.
In Lua they are called the "upvalues" of the function.
Examples.
Nested functions.
In the Python 3 example that follows there is a nested function codice_1 defined in the scope of another function codice_2. The variable codice_3 is local to codice_2, but non-local to codice_1 (nor is it global):
def outer():
 x = 1
 def inner():
 nonlocal x
 x += 1
 print(x)
 return inner
In Javascript, the locality of a variable is determined by the closest codice_6 statement for this variable. In the following example, codice_3 is local to codice_2 as it contains a codice_9 statement, while codice_1 doesn't. Therefore, x is non-local to codice_1:
function outer() {
 var x = 1;
 function inner() {
 x += 1;
 console.log(x);
 return inner;
Anonymous functions.
In the Haskell example that follows the variable codice_12 is non-local in the anonymous function codice_13:
outer = let c = 1 in map (\x -> x + c) [1, 2, 3, 4, 5]
Implementation issues.
Non-local variables are the primary reason it is difficult to support nested, anonymous, higher-order and thereby first-class functions in a programming language.
If the nested function or functions are (mutually) recursive, it becomes hard for the compiler to know exactly where on the call stack the non-local variable was allocated, as the frame pointer only points to the local variable of the nested function itself and there can be an arbitrary number of activation records on the stack in between. This is generally solved using access links or display registers.
If the nested function is passed as an argument to a higher-order function a closure needs to be built in order to locate the non-local variables. If the nested function is returned as a result from its outer function (or stored in a variable) the non-local variables will no longer be available on the stack. They need to be heap allocated instead, and their lifetime extends beyond the lifetime of the outer function that declared and allocated them. This generally requires garbage-collection.