Closures in programming.

Closure is a function that retains access to variables from its lexical scope even after the external function has completed execution. This is a powerful concept in programming, especially in languages with support for functional programming.

In the presented example on Julia, we see a classic closure implementation.:

function make_counter()
    count = 0  # Эта переменная «замыкается» внутри функции
    function counter()
        count += 1
        return count
    end
    return counter
end

make_counter (generic function with 1 method)

Here make_counter is a factory function that creates and returns a function counter. Internal function counter has access to a variable count even after make_counter completes its execution.

How short circuits work

Variable Capture: When a closure is created, it "remembers" all variables from its surrounding scope.
State: These variables retain their state between closure calls.
Isolation: Each new closure creates its own copy of the captured variables.

In our example, each call is make_counter() creates a new closure with its own variable count:

my_counter = make_counter()  # Создаем первое замыкание
println("my_counter: $my_counter")
another_counter = make_counter()  # Создаем второе независимое замыкание
println("another_counter: $another_counter")

my_counter: counter
another_counter: counter

To use it, it is enough to call the created counters.

println("my_counter первый вызов: $(my_counter())")  
println("my_counter второй вызов: $(my_counter())")  
println("Вызов another_counter: $(another_counter())")

my_counter первый вызов: 1
my_counter второй вызов: 2
Вызов another_counter: 1

Practical applications of closures are, for example, the implementation of private variables.

function create_person(name)
    age = 0
    function get_name()
        return name
    end
    function get_age()
        return age
    end
    function have_birthday()
        age += 1
        return age
    end
    return (get_name=get_name, get_age=get_age, have_birthday=have_birthday)
end

person = create_person("Alice")
println(person.get_name())  # Alice
println(person.have_birthday())  # 1

Alice
1

Or memoization (caching of results)

function make_cached(f)
    cache = Dict()
    function cached(x)
        if !haskey(cache, x)
            cache[x] = f(x)
        end
        return cache[x]
    end
    return cached
end

# Пример использования
expensive_computation(x) = (sleep(1); x^2)
cached_comp = make_cached(expensive_computation)

println(cached_comp(2))  # Вычисляется (занимает время)
println(cached_comp(2))  # Берется из кеша (мгновенно)

4
4

It is also possible to create functions with preset parameters.

function make_multiplier(factor)
    function multiplier(x)
        return x * factor
    end
    return multiplier
end

double = make_multiplier(2)
triple = make_multiplier(3)

println(double(5))  # 10
println(triple(5))  # 15

10
15

Conclusion

To summarize, it is worth analyzing the pros and cons of this approach.
Advantages:

Encapsulation and data hiding,
Creating stateful functions,
flexibility in creating specialized functions,
Support for functional programming patterns.

Disadvantages:

Memory consumption (captured variables are not released),
possible difficulties with debugging

In conclusion, I would like to say that closures are a powerful tool. They are used in many fields, from simple counters to the implementation of complex design patterns. Understanding closures is important for any developer working with languages that support functionality.

The presented examples demonstrate only a small part of the possibilities of closures. By experimenting with them, you will be able to find more and more new ways to apply this concept in your projects.