Почему Go не допускает объявления вложенных функций (функций внутри функций)?

Изменить: если было неясно, о чем я спрашивал: какие проблемы можно смягчить, запретив декларации вложенных функций?

Лямбды работают должным образом:

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

Однако следующее объявление внутри объявления не допускается:

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

По какой причине нельзя использовать вложенные функции?

Я думаю, что есть 3 причины, по которым эта очевидная функция не разрешена

1. Это немного усложнило бы компилятор. На данный момент компилятор знает, что все функции находятся на верхнем уровне.
2. Это привело бы к новому классу ошибки программиста - вы могли бы что-то реорганизовать и случайно вложить некоторые функции.
3. Иметь другой синтаксис для функций и замыканий - это хорошо. Выполнение закрытия потенциально дороже, чем выполнение функции, поэтому вы должны знать, что делаете это.

Это всего лишь мое мнение - я не видел официального заявления разработчиков языка.

Конечно, есть. Вам просто нужно присвоить их переменной:

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

Часто задаваемые вопросы (FAQ)

Почему в Go нет функции X?

Каждый язык содержит новые функции и пропускает чьи-то любимые функции. Go был разработан с учетом совершенства программирования, скорости компиляции, ортогональности концепций и необходимости поддержки таких функций, как параллелизм и сборка мусора. Ваша любимая функция может отсутствовать, потому что она не подходит, потому что она влияет на скорость компиляции или ясность дизайна, или потому что это сделает фундаментальную модель системы слишком сложной.

Если вас беспокоит, что в Go отсутствует функция X, простите нас и изучите возможности, которые есть в Go. Вы можете обнаружить, что они интересными способами компенсируют отсутствие сертификатов X.

Чем можно оправдать сложность и дороговизну добавления вложенных функций? Что вы хотите сделать из того, что не можете сделать без вложенных функций? И так далее.

Вот способ реализовать вложенные функции и функции внутри вложенных функций

package main

    import "fmt"

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

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

            deeplyNested()
        }

        nested()
    }

В Go разрешены вложенные функции. Вам просто нужно назначить их локальным переменным во внешней функции и вызывать их с использованием этих переменных.

Пример:

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

Внутренние функции часто удобны для локальных горутин:

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

Просто надо сразу его вызвать, добавив ()в конец.

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

Изменить: не может иметь имя функции ... так что сразу вызывается просто лямбда-функция:

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