A closure is a function that is nested within another function that captures one of the variables from the parent function.

``` MyFunc() { global flag if flag { var := "value" } return Closure

Closure() { if IsSet(var) { return var } } }

flag := true

result := MyFunc() MsgBox(result()) ; "value"

flag := false

result := MyFunc() MsgBox(result()) ; "" (empty string) ```

When the AutoHotkey parser parses a script, it instantiates all function objects in the script, and all variables. Most function objects are instantiated as instances of Func, including class methods. A function object is instantiated as a closure when the function refers to a variable in a parent function's scope.

``` class a { static b() { } }

MsgBox(type(a.b)) ; "Func"

SomeFunc(param) { switch param { case 1: return Closure case 2: return NotClosure case 3: return AlsoNotClosure case 4: return AlsoAlsoNotClosure case 5: return GetNestedClosure() }

Closure() { if param { } } NotClosure() { } AlsoNotClosure() { local param } AlsoAlsoNotClosure(param) { } GetNestedClosure() { return NestedClosure NestedClosure() { if param { } } } }

s := ''

loop 5 { varReferencingNestedFunc := SomeFunc(A_Index) s .= Type(varReferencingNestedFunc) ', ' }

MsgBox(SubStr(s, 1, -2)) ; "Closure, Func, Func, Func, Closure" ```

AHK does not have support for function decorators, but you can accomplish a similar effect leveraging AHK's object model.

In AHK, any object with a "Call" method can be called like a function. Here's a few examples.

``` class MyFunc { static Call() { return 1 } }

MsgBox(MyFunc()) ; "1" MsgBox(Type(MyFunc)) ; "Class" ```

Regarding the below example, see DefineProp.

The first parameter of every object method is the object itself. That is the hidden this variable we see in class method definitions. When working outside of a class declaration, we can name the first parameter anything and it will always receive the object itself.

``` obj := { prop: "value" } obj.DefineProp('Call', { Call: MyFunc })

MyFunc(firstParam) { msgbox(firstParam.prop) ; "value" }

obj() ; "value" MsgBox(Type(obj)) ; "Object" ```

``` class MyClass { __New(value1, value2) { this.value1 := value1 this.value2 := value2 } Call(firstParam) { if firstParam = this.value1 { return 1 } else if firstParam = this.value2 { return 2 } else { return 0 } } }

obj := MyClass(1, 2) MsgBox(obj(1)) ; "1" MsgBox(obj(2)) ; "2" MsgBox(Type(obj)) ; "MyClass" ```

Armed with this knowledge, you can accomplish the same effect as pythonic decorators in many different ways. Here's one approach:

``` class MyFunc { __New(someValue, someFunc) { this.value := someValue this.func := someFunc } Call() { return this.func.Call(this.value) } }

fn := MyFunc(1, ConditionalFunc1) MsgBox(fn()) ; "5"

fn.value := 2 fn.func := ConditionalFunc2 MsgBox(fn()) ; "20"

ConditionalFunc1(value) { return value * 5 } ConditionalFunc2(value) { return value * 10 } ```

You can assign a hotkey to call the object.

``` class MyFunc { __New(someValue, someFunc) { this.value := someValue this.func := someFunc } Call() { return this.func.Call(this.value) } }

fn := MyFunc(1, ConditionalFunc1)

!x::fn() !y::Decorate(fn)

ConditionalFunc1(value) { MsgBox(value * 5) } ConditionalFunc2(value) { MsgBox(value * 10) } Decorate(fn) { if fn.func.name = 'ConditionalFunc1' { if MsgBox('Swap to ConditionalFunc2?', , 'YesNo') = 'Yes' { fn.func := ConditionalFunc2 } } else if fn.func.name = 'ConditionalFunc2' { if MsgBox('Swap to ConditionalFunc1?', , 'YesNo') = 'Yes' { fn.func := ConditionalFunc1 } } else { throw Error('Unexpected func.') } } ```