====== Closures in Lua ======

===== 1. Basic Concept of Closures =====
Closures are an essential concept in programming that allows functions in Lua to retain their environment even after they have finished executing. They enable functions to access variables and functions from the scope in which they were created without needing to know the original scope.

===== 2. How Closures Work =====

In Lua, every time a function is created, it can have its own separate environment. This environment contains local variables, function parameters, and even global variables that the function can access.

When a function is created inside another function and it references variables or parameters from the outer function, it captures those values into its closure.

==== 3. Example Illustration ====
<code LUA>
function outerFunction(x)
    -- Define innerFunction
    local function innerFunction(y)
        return x + y  -- innerFunction uses variable x from outerFunction
    end
    return innerFunction  -- outerFunction returns innerFunction
end

local closure = outerFunction(10)  -- closure now is innerFunction with x = 10

print(closure(5))  -- Result: 15, because closure captures x = 10 from outerFunction
</code>

In this example:

//outerFunction// creates an ///innerFunction// and returns it.
//innerFunction// uses the variable //x// from //outerFunction// as part of its closure.
When //closure// is called with the argument //5//, it uses the captured value //x = 10// from //outerFunction// and returns //15//.

===== 4. Advanced Examples and Concepts =====
**Using Closures to Create Private Variables**
<code LUA>
function createCounter()
    local count = 0  -- Variable count held by closure

    return function()
        count = count + 1
        return count
    end
end

local counter1 = createCounter()
print(counter1())  -- Result: 1
print(counter1())  -- Result: 2

local counter2 = createCounter()
print(counter2())  -- Result: 1 (a new count set)
</code>

In this example, //createCounter// returns a function where //count// is a local variable but held by the closure of the returned function. Each time the returned function is called, //count// is incremented and its value persists between calls.

===== Using Closures for Callback Functions =====

<code LUA>
function performOperation(x, y, operation)
    local result = operation(x, y)
    print("Result:", result)
end

function add(x, y)
    return x + y
end

function subtract(x, y)
    return x - y
end

performOperation(10, 5, add)       -- Result: 15
performOperation(10, 5, subtract)  -- Result: 5
</code>

In this example, add and subtract functions are passed as callback functions to performOperation. Each function uses closures to access x and y values from performOperation.

Using Closures to Model Simple Objects
<code LUA>
function createPerson(name, uid)
    local person = {}
 
    person.getName = function()
        return name
    end
 
    person.getUid = function()
        return uid
    end
 
    person.sayHello = function()
        print("Hello, my name is " .. name .. " and My UID " .. uid .. ".")
    end
 
    return person
end
 
local john = createPerson("Don", 209525865)
print(john.getName())   -- Result: Don
print(john.getUid())    -- Result: 209525865
john.sayHello()         -- Result: Hello, my name is Don and My UID is 209525865.

</code>

{{:developer_center:developer_editor:script:screenshot-20240813-112541.png?nolink|}}

In this example, createPerson creates an object person using closures to encapsulate name and age. The object's methods (getName, getAge, sayHello) can access and use these variables through closures.

==== Advanced Knowledge ====

Closure and Garbage Collection
Lua manages closure memory automatically. When there are no references to a closure anymore, Lua will automatically release the memory associated with it.

==== Closure and Performance ====

Using too many closures may impact application performance because each closure needs to maintain its own memory. However, at a basic level, this concern is minimal, and closures are typically used efficiently in Lua.

==== Closure Conditions ====

Lua allows closures to change outer variables' values, which can lead to closure conditions. This can sometimes make code harder to understand and debug.

==== Conclusion ====

Closures are a fundamental concept in Lua that allows for flexible and reusable code. Understanding and effectively using closures empowers you to harness Lua's capabilities to write efficient and maintainable applications.