Kif jaħdmu l-closures f'Go?

Question

Accepted Answer

A **closure** hija funzjoni li tirreferi għal varjabbli mill-iskop li jdawwiruha, "twassal" magħhom — il-funzjoni żżomm l-aċċess għal dawk il-varjabbli anqas wara li l-funzjoni li tiddeċieva torqod. Il-funzjonijiet Go huma first-class values, li jagħmlu closure għodda komuni u qawwija.

## Closure bażiku

```go
func makeCounter() func() int {
    count := 0                  // a local variable
    return func() int {          // this inner function CLOSES OVER count
        count++                  // it can read AND modify count
        return count
    }
}

counter := makeCounter()
fmt.Println(counter())   // 1
fmt.Println(counter())   // 2 — count PERSISTS between calls (state is retained)

other := makeCounter()    // a NEW, independent closure with its own count
fmt.Println(other())     // 1 — separate state
```

Il-funzjoni rritornata żżomm referenza għal `count` anqas wara li `makeCounter` torqod — allura l-istat ipersistu madwar it-tlaqliq. Kull tlaqliq għal `makeCounter` joħloq `count` ġdid u indipendenti. Din hija stat privat inkapsulat.

## Il-closures jistaħbu l-varjabbli permezz ta' REFERENZA (punt ewlieni)

```go
// closures capture the variable itself, not a snapshot of its value
x := 10
f := func() int { return x }
x = 20
fmt.Println(f())   // 20 — sees the CURRENT value of x, not 10
```

## Il-problema klassika tal-varjabbli tal-loop

```go
// ⚠️ in Go versions BEFORE 1.22:
funcs := []func(){}
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() { fmt.Println(i) })  // all close over the SAME i
}
for _, f := range funcs { f() }   // prints 3, 3, 3 (not 0, 1, 2)! — all share i

// the classic fix (pre-1.22): make a per-iteration copy
for i := 0; i < 3; i++ {
    i := i                          // shadow with a new variable each iteration
    funcs = append(funcs, func() { fmt.Println(i) })
}
// Note: Go 1.22+ changed loop semantics so each iteration gets a NEW variable — this bug is fixed.
```

Din hija bug famuża: il-closures f'loop kullhom stħabbu l-varjabbli tal-loop *l-istess*. (Go 1.22 ħarreg l-iskopi tal-varjabbli tal-loop, iżda l-fehim tal-problema hu importanti għal kodiċi antiki u varjabbli oħra mistaħbija.)

## L-użi komuni tal-closures

```go
// 1. as callbacks / handlers
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { ... })

// 2. deferred functions capturing local state
defer func() { fmt.Println("cleanup with", localVar) }()

// 3. function factories (configured behavior)
func multiplier(factor int) func(int) int {
    return func(n int) int { return n * factor }
}
double := multiplier(2)   // double(5) → 10
```

## Għaliex Hu Importanti

Il-closures huma feature qawwija u użata ta' spiss ta' Go attivata minn funzjonijiet first-class — jillokkja lill-funzjonijiet li jistgħu jġibdu stat privat u persistent (counters, ġeneraturi, imsiemen konfigurat permezz ta' factory functions) u huma essenzjali għal callbacks, HTTP handlers, deferred cleanup li jirreferi għal varjabbli lokali, u pattern funzjonali.

L-fehim li l-closures jistħabbu l-varjabbli **permezz ta' referenza** (jiddu l-valuri attwali, jaqsmu l-istat) — mhux permezz ta' valur — hu krucjali kemm għall-użu tagħhom b'mod effettiv (istat mutabbli inkapsulat) kif ukoll biex jiġbu evitati l-**bug klassiku tal-istħbija tal-varjabbli tal-loop** (il-closures kollha jaqsmu varjabbli wieħed, sorġent notorju tal-ħasra, iħarreg f'Go 1.22 iżda xorta ta' rilevanti għal kodiċi antiki u istħbija mhux-loop).

Il-closures jidhru madwar Go idiomatiku u APIs tal-standard-library, li jagħmluhom għarfien prattiku importanti u tema ta' intervista recurring.