Dlaczego Go nie zezwala na deklaracje funkcji zagnieżdżonych (funkcje wewnątrz funkcji)?

Edycja: Jeśli nie było jasne, o co pytałem: jakie problemy można złagodzić, nie zezwalając na zagnieżdżone deklaracje funkcji?

Lambdy działają zgodnie z oczekiwaniami:

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

Jednak następująca deklaracja w deklaracji nie jest dozwolona:

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

Z jakiego powodu funkcje zagnieżdżone są niedozwolone?

Myślę, że są 3 powody, dla których ta oczywista funkcja jest niedozwolona

1. To trochę skomplikowałoby kompilator. W tej chwili kompilator wie, że wszystkie funkcje są na najwyższym poziomie.
2. Spowodowałoby to nową klasę błędu programisty - można by coś zmienić i przypadkowo zagnieździć niektóre funkcje.
3. Posiadanie innej składni dla funkcji i domknięć jest dobrą rzeczą. Wykonanie zamknięcia jest potencjalnie droższe niż wykonanie funkcji, więc powinieneś wiedzieć, że to robisz.

To tylko moje opinie - nie widziałem oficjalnego oświadczenia projektantów języka.

Jasne, że tak. Wystarczy przypisać je do zmiennej:

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

Często zadawane pytania (FAQ)

Dlaczego Go nie ma funkcji X?

Każdy język zawiera nowe funkcje i pomija czyjąś ulubioną funkcję. Go został zaprojektowany z myślą o łatwości programowania, szybkości kompilacji, ortogonalności koncepcji oraz potrzebie obsługi takich funkcji, jak współbieżność i usuwanie elementów bezużytecznych. Może brakować Twojej ulubionej funkcji, ponieważ nie pasuje, ponieważ wpływa na szybkość kompilacji lub przejrzystość projektu, lub ponieważ może utrudnić podstawowy model systemu.

Jeśli przeszkadza Ci to, że w Go brakuje funkcji X, wybacz nam i zbadaj funkcje, które ma Go. Może się okazać, że w interesujący sposób rekompensują one brak X.

Co uzasadniałoby złożoność i koszt dodawania funkcji zagnieżdżonych? Co chcesz zrobić, czego nie możesz zrobić bez funkcji zagnieżdżonych? I tak dalej.

Oto sposób implementacji zagnieżdżonych funkcji i funkcji w zagnieżdżonych funkcjach

package main

    import "fmt"

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

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

            deeplyNested()
        }

        nested()
    }

Zagnieżdżone funkcje są dozwolone w Go. Wystarczy przypisać je do zmiennych lokalnych w funkcji zewnętrznej i wywołać je przy użyciu tych zmiennych.

Przykład:

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

Funkcje wewnętrzne są często przydatne w przypadku lokalnych gorutyn:

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

Musisz tylko natychmiast to wywołać, dodając ()na końcu.

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

Edycja: nie może mieć nazwy funkcji ... więc jest to tylko funkcja lambda, która jest wywoływana od razu:

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