Let's help each other out
https://www.autohotkey.com/boards/
https://www.autohotkey.com/boards/viewtopic.php?f=14&t=129296
Code: Select all
Closure.Prototype.__Delete := this => OutputDebug('closure dctor: ' ObjPtr(this) '`n')
ff() {
a := 0
b := f2
OutputDebug('f1: ' ObjPtr(f1) '`n')
OutputDebug('f2: ' ObjPtr(f2) '`n')
f1()
; b := 0 ; Free variables was not released during closure destruction.
f1() {
b()
}
f2() {
a := 1
}
}
ff()
There is no "closure destruction" while a counted reference to the closure still exists, even if it is cyclic. It is the same for all objects. The reference to f1 is not cyclic because f1 is not captured by any closure.It is best not to store a reference to a closure in any of the closure's own free variables, since that creates a circular reference which must be broken (such as by clearing the variable) before the closure can be freed. However, a closure may safely refer to itself and other closures by their original variables without creating a circular reference.
Source: Functions - Definition & Usage | AutoHotkey v2
Code: Select all
f() {
a := 0
b := { __delete: (*) => MsgBox() }
f1() {
(b)
}
f2(s?) {
(a)
s := 'b'
MsgBox(IsSet(%s%))
s := 'f1'
MsgBox(IsSet(%s%))
}
return f2
}
t := f()
t()
As you see, f2 does not refer to f1 or b non-dynamically, therefore it does not capture them, and cannot access them dynamically.By default, a nested function automatically "captures" a non-static local variable of an outer function when the following requirements are met:...
- ...
- The inner function (or a function nested inside it) must refer to the variable non-dynamically.
Non-static local variables of the outer function cannot be accessed dynamically unless they have been captured.
Source: Functions - Definition & Usage | AutoHotkey v2
A closure is a nested function bound to a set of free variables. Free variables are local variables of the outer function which are also used by nested functions.
Source: Functions - Definition & Usage | AutoHotkey v2
Each time the outer function is called, all of its free variables are allocated as a set. This one set of free variables is linked to all of the function's closures. If the closure's original variable (tick in the example above) is captured by another closure within the same function, its lifetime is bound to the set. The set is deleted only when no references exist to any of its closures, except those in the original variables. This allows closures to refer to each other without causing a problematic reference cycle.
Closures which are not captured by other closures can be deleted before the set. All of the free variables within the set, including captured closures, cannot be deleted while such a closure exists.
Source: Functions - Definition & Usage | AutoHotkey v2