Quali sono i problemi che vengono mitigati non consentendo dichiarazioni di funzioni annidate in Go?

Lambda funziona come previsto:

func main() {
    inc := func(x int) int { return x+1; }
}

Tuttavia, la seguente dichiarazione all'interno di una dichiarazione non è consentita:

func main() {
    func inc(x int) int { return x+1; }
}

Per quale motivo le funzioni annidate non sono consentite?

Penso che ci siano 3 ragioni per cui questa caratteristica ovvia non è consentita

1. Complicherebbe leggermente il compilatore. Al momento il compilatore sa che tutte le funzioni sono al livello più alto.
2. Creerebbe una nuova classe di errori del programmatore: potresti rifattorizzare qualcosa e annidare accidentalmente alcune funzioni.
3. Avere una sintassi diversa per le funzioni e le chiusure è una buona cosa. Fare una chiusura è potenzialmente più costoso che realizzare una funzione, quindi dovresti sapere che lo stai facendo.

Queste sono solo le mie opinioni però - non ho visto un pronunciamento ufficiale dei progettisti del linguaggio.

Certo che lo sono. Devi solo assegnarli a una variabile:

func main() {
    inc := func(x int) int { return x+1; }
}

Domande frequenti (FAQ)

Perché Go non ha la funzione X?

Ogni lingua contiene nuove funzionalità e omette la caratteristica preferita di qualcuno. Go è stato progettato con un occhio alla felicità della programmazione, alla velocità di compilazione, all'ortogonalità dei concetti e alla necessità di supportare funzionalità come la concorrenza e la raccolta dei rifiuti. La tua funzione preferita potrebbe mancare perché non si adatta, perché influisce sulla velocità di compilazione o sulla chiarezza del design o perché renderebbe troppo difficile il modello di sistema fondamentale.

Se ti dà fastidio il fatto che Go non abbia la funzione X, perdonaci e analizza le funzionalità di Go. Potresti scoprire che compensano in modi interessanti la mancanza di X.

Cosa giustificherebbe la complessità e il costo dell'aggiunta di funzioni annidate? Cosa vuoi fare che non puoi fare senza funzioni annidate? Eccetera.

Ecco un modo per implementare funzioni e funzioni annidate all'interno di funzioni annidate

package main

    import "fmt"

    func main() {
        nested := func() {
            fmt.Println("I am nested")

            deeplyNested := func() {
                fmt.Println("I am deeply nested")
            }

            deeplyNested()
        }

        nested()
    }

Le funzioni annidate sono consentite in Go. Hai solo bisogno di assegnarli a variabili locali all'interno della funzione esterna e chiamarli usando quelle variabili.

Esempio:

func outerFunction(iterations int, s1, s2 string) int {
    someState := 0
    innerFunction := func(param string) int {
        // Could have another nested function here!
        totalLength := 0
        // Note that the iterations parameter is available
        // in the inner function (closure)
        for i := 0; i < iterations; i++) {
            totalLength += len(param)
        }
        return totalLength
    }
    // Now we can call innerFunction() freely
    someState = innerFunction(s1)
    someState += innerFunction(s2)
    return someState
}
myVar := outerFunction(100, "blah", "meh")

Le funzioni interne sono spesso utili per i goroutine locali:

func outerFunction(...) {
    innerFunction := func(...) {
        ...
    }
    go innerFunction(...)
}

Devi solo chiamarlo immediatamente aggiungendo ()alla fine.

func main() {
    func inc(x int) int { return x+1; }()
}

Modifica: non può avere il nome della funzione ... quindi è solo una funzione lambda che viene chiamata subito:

func main() {
    func(x int) int { return x+1; }()
}