Pourquoi Go n'autorise-t-il pas les déclarations de fonctions imbriquées (fonctions à l'intérieur de fonctions)?

Edit: Si ce que je demandais n'était pas clair: quels sont les problèmes qui sont atténués en n'autorisant pas les déclarations de fonctions imbriquées?

Les lambdas fonctionnent comme prévu:

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

Cependant, la déclaration suivante dans une déclaration n'est pas autorisée:

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

Pour quelle raison les fonctions imbriquées ne sont-elles pas autorisées?

Je pense qu'il y a 3 raisons pour lesquelles cette fonctionnalité évidente n'est pas autorisée

1. Cela compliquerait légèrement le compilateur. Pour le moment, le compilateur sait que toutes les fonctions sont au niveau supérieur.
2. Cela créerait une nouvelle classe d'erreur de programmeur - vous pourriez refactoriser quelque chose et imbriquer accidentellement certaines fonctions.
3. Avoir une syntaxe différente pour les fonctions et les fermetures est une bonne chose. Faire une fermeture est potentiellement plus coûteux que créer une fonction, vous devez donc savoir que vous le faites.

Ce ne sont cependant que mes opinions - je n'ai pas vu de déclaration officielle des concepteurs de langage.

Bien sûr qu'ils le sont. Il vous suffit de les affecter à une variable:

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

Foire aux questions (FAQ)

Pourquoi Go n'a-t-il pas la fonctionnalité X?

Chaque langue contient de nouvelles fonctionnalités et omet la fonctionnalité préférée de quelqu'un. Go a été conçu en tenant compte de la félicité de la programmation, de la vitesse de compilation, de l'orthogonalité des concepts et de la nécessité de prendre en charge des fonctionnalités telles que la concurrence et le ramassage des ordures. Votre fonctionnalité préférée peut manquer parce qu'elle ne convient pas, parce qu'elle affecte la vitesse de compilation ou la clarté de la conception, ou parce qu'elle rendrait le modèle système fondamental trop difficile.

Si la fonctionnalité X de Go vous dérange, veuillez nous pardonner et examiner les fonctionnalités de Go. Vous constaterez peut-être qu'ils compensent de manière intéressante le manque de X.

Qu'est-ce qui justifierait la complexité et le coût de l'ajout de fonctions imbriquées? Que voulez-vous faire que vous ne pouvez pas faire sans fonctions imbriquées? Etc.

Voici un moyen d'implémenter des fonctions imbriquées et des fonctions dans des fonctions imbriquées

package main

    import "fmt"

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

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

            deeplyNested()
        }

        nested()
    }

Les fonctions imbriquées sont autorisées dans Go. Il vous suffit de les affecter à des variables locales dans la fonction externe et de les appeler en utilisant ces variables.

Exemple:

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")

Les fonctions internes sont souvent utiles pour les goroutines locales:

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

Il vous suffit de l'appeler immédiatement en ajoutant ()à la fin.

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

Edit: ne peut pas avoir de nom de fonction ... donc c'est juste une fonction lambda qui est appelée tout de suite:

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