Por que o Go não permite declarações de funções aninhadas (funções dentro de funções)?

Edit: Se não ficou claro o que eu estava perguntando: quais são os problemas que são mitigados por não permitir declarações de funções aninhadas?

Lambdas funcionam conforme o esperado:

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

No entanto, a seguinte declaração dentro de uma declaração não é permitida:

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

Por que razão as funções aninhadas não são permitidas?

Acho que há três razões pelas quais esse recurso óbvio não é permitido

1. Isso complicaria um pouco o compilador. No momento, o compilador sabe que todas as funções estão no nível superior.
2. Isso causaria uma nova classe de erro do programador - você poderia refatorar algo e acidentalmente aninhar algumas funções.
3. Ter uma sintaxe diferente para funções e encerramentos é uma coisa boa. Fazer um fechamento é potencialmente mais caro do que fazer uma função, portanto, você deve saber o que está fazendo.

Essas são apenas minhas opiniões - eu não vi um pronunciamento oficial dos designers da linguagem.

Claro que estão. Você só precisa atribuí-los a uma variável:

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

Perguntas frequentes (FAQ)

Por que Go não possui o recurso X?

Cada idioma contém novos recursos e omite o recurso favorito de alguém. Go foi projetado com foco na felicidade da programação, velocidade de compilação, ortogonalidade de conceitos e a necessidade de oferecer suporte a recursos como concorrência e coleta de lixo. Seu recurso favorito pode estar faltando porque não se encaixa, porque afeta a velocidade de compilação ou a clareza do design, ou porque tornaria o modelo fundamental do sistema muito difícil.

Se o incomoda que o Go não tenha o recurso X, perdoe-nos e investigue os recursos que o Go tem. Você pode descobrir que eles compensam de maneiras interessantes a falta de X.

O que justificaria a complexidade e o custo de adicionar funções aninhadas? O que você quer fazer que não pode fazer sem funções aninhadas? Et cetera.

Esta é uma maneira de implementar funções aninhadas e funções dentro de funções aninhadas

package main

    import "fmt"

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

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

            deeplyNested()
        }

        nested()
    }

Funções aninhadas são permitidas no Go. Você só precisa atribuí-los a variáveis ​​locais dentro da função externa e chamá-los usando essas variáveis.

Exemplo:

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

As funções internas costumam ser úteis para goroutines locais:

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

Você apenas tem que chamá-lo imediatamente adicionando ()ao final.

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

Editar: não pode ter nome de função ... então é apenas uma função lambda sendo chamada imediatamente:

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