Apa masalah yang dapat diatasi dengan tidak mengizinkan deklarasi fungsi bertingkat di Go?

Lambdas bekerja seperti yang diharapkan:

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

Namun, pernyataan berikut di dalam deklarasi tidak diperbolehkan:

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

Untuk alasan apa fungsi bertingkat tidak diizinkan?

Saya rasa ada 3 alasan mengapa fitur yang jelas ini tidak diperbolehkan

1. Ini akan sedikit mempersulit kompiler. Saat ini kompilator mengetahui bahwa semua fungsi berada di level teratas.
2. Ini akan membuat kelas baru dari kesalahan programmer - Anda dapat memfaktor ulang sesuatu dan secara tidak sengaja membuat sarang beberapa fungsi.
3. Memiliki sintaks yang berbeda untuk fungsi dan closure adalah hal yang baik. Membuat penutupan berpotensi lebih mahal daripada membuat suatu fungsi jadi Anda harus tahu Anda sedang melakukannya.

Itu hanya pendapat saya - saya belum melihat pernyataan resmi dari desainer bahasa.

Tentu mereka. Anda hanya perlu menetapkannya ke variabel:

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

Pertanyaan yang Sering Diajukan (FAQ)

Mengapa Go tidak memiliki fitur X?

Setiap bahasa berisi fitur baru dan menghilangkan fitur favorit seseorang. Go dirancang dengan memperhatikan kesesuaian pemrograman, kecepatan kompilasi, ortogonalitas konsep, dan kebutuhan untuk mendukung fitur seperti konkurensi dan pengumpulan sampah. Fitur favorit Anda mungkin hilang karena tidak sesuai, karena memengaruhi kecepatan kompilasi atau kejelasan desain, atau karena akan membuat model sistem dasar terlalu sulit.

Jika Anda merasa terganggu karena Go tidak memiliki fitur X, maafkan kami dan selidiki fitur yang dimiliki Go. Anda mungkin menemukan bahwa mereka mengimbangi dengan cara yang menarik untuk kurangnya X.

Apa yang membenarkan kerumitan dan biaya penambahan fungsi bersarang? Apa yang ingin Anda lakukan yang tidak dapat Anda lakukan tanpa fungsi bertingkat? Dan lain-lain.

Berikut cara untuk mengimplementasikan fungsi dan fungsi bertingkat dalam fungsi bertingkat

package main

    import "fmt"

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

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

            deeplyNested()
        }

        nested()
    }

Fungsi bertingkat diperbolehkan di Go. Anda hanya perlu menetapkannya ke variabel lokal di dalam fungsi luar, dan memanggilnya menggunakan variabel tersebut.

Contoh:

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

Fungsi bagian dalam sering kali berguna untuk goroutine lokal:

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

Anda hanya perlu segera memanggilnya dengan menambahkan di ()bagian akhir.

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

Sunting: tidak dapat memiliki nama fungsi ... jadi itu hanya fungsi lambda yang dipanggil langsung:

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