Warum erlaubt Go keine verschachtelten Funktionsdeklarationen (Funktionen innerhalb von Funktionen)?

Bearbeiten: Wenn nicht klar war, was ich gefragt habe: Welche Probleme werden gemildert, wenn verschachtelte Funktionsdeklarationen nicht zugelassen werden?

Lambdas arbeiten wie erwartet:

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

Die folgende Erklärung innerhalb einer Erklärung ist jedoch nicht zulässig:

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

Aus welchem ​​Grund sind verschachtelte Funktionen nicht zulässig?

Ich denke, es gibt drei Gründe, warum diese offensichtliche Funktion nicht erlaubt ist

1. Dies würde den Compiler etwas komplizieren. Im Moment weiß der Compiler, dass sich alle Funktionen auf der obersten Ebene befinden.
2. Es würde eine neue Klasse von Programmiererfehlern verursachen - Sie könnten etwas umgestalten und versehentlich einige Funktionen verschachteln.
3. Eine andere Syntax für Funktionen und Abschlüsse ist eine gute Sache. Das Erstellen eines Verschlusses ist möglicherweise teurer als das Erstellen einer Funktion. Sie sollten also wissen, dass Sie dies tun.

Dies sind jedoch nur meine Meinungen - ich habe keine offizielle Erklärung der Sprachdesigner gesehen.

Sicher sind sie. Sie müssen sie nur einer Variablen zuweisen:

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

Häufig gestellte Fragen (FAQ)

Warum hat Go kein Feature X?

Jede Sprache enthält neuartige Merkmale und lässt das Lieblingsmerkmal einer Person aus. Go wurde mit Blick auf die Glückseligkeit der Programmierung, die Geschwindigkeit der Kompilierung, die Orthogonalität der Konzepte und die Notwendigkeit entwickelt, Funktionen wie Parallelität und Speicherbereinigung zu unterstützen. Ihre Lieblingsfunktion fehlt möglicherweise, weil sie nicht passt, weil sie die Kompilierungsgeschwindigkeit oder die Klarheit des Designs beeinträchtigt oder weil dies das grundlegende Systemmodell zu schwierig machen würde.

Wenn es Sie stört, dass Go Feature X fehlt, verzeihen Sie uns bitte und untersuchen Sie die Funktionen von Go. Sie werden vielleicht feststellen, dass sie das Fehlen von X auf interessante Weise kompensieren.

Was würde die Komplexität und die Kosten des Hinzufügens verschachtelter Funktionen rechtfertigen? Was möchten Sie tun, was Sie ohne verschachtelte Funktionen nicht tun können? Und so weiter.

Hier ist eine Möglichkeit, verschachtelte Funktionen und Funktionen in verschachtelten Funktionen zu implementieren

package main

    import "fmt"

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

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

            deeplyNested()
        }

        nested()
    }

Verschachtelte Funktionen sind in Go zulässig. Sie müssen sie nur lokalen Variablen innerhalb der äußeren Funktion zuweisen und sie mit diesen Variablen aufrufen.

Beispiel:

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

Innere Funktionen sind für lokale Goroutinen oft nützlich:

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

Sie müssen es nur sofort aufrufen, indem Sie ()es am Ende hinzufügen .

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

Bearbeiten: kann keinen Funktionsnamen haben ... es ist also nur eine Lambda-Funktion, die sofort aufgerufen wird:

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