Fale conosco
Desenvolvimento

Go 1.28 vai aceitar `return {...}, nil`: composite literals passam a inferir o tipo do contexto

27 min de leitura
Go 1.28 vai aceitar `return {...}, nil`: composite literals passam a inferir o tipo do contexto

Go 1.28 vai aceitar return {...}, nil : composite literals passam a inferir o tipo do contexto

Quem escreve Go há algum tempo conhece o ritual: dentro de um slice, array ou map, o tipo do elemento pode ser omitido; fora deles, não. Ou seja, []Point{{1, 2}, {3, 4}} compila, mas return Point{1, 2} é obrigatório — mesmo quando a assinatura da função já diz que o retorno é Point .

A proposta golang/go#12854 , aberta por Damien Neil em outubro de 2015 e aceita em abril deste ano após mais de 260 comentários, muda exatamente isso. Ela estende a elisão de tipo dos composite literals para qualquer contexto em que o tipo esperado já esteja definido. Segundo o rascunho das notas de release e o histórico do branch de desenvolvimento, a mudança está implementada e caminha para o Go 1.28 , previsto para fevereiro de 2027. Nada disso está em versão estável hoje — e é justamente por isso que vale entender agora, antes de o primeiro código aparecer em revisão.

A relevância é menos sobre economizar seis caracteres e mais sobre onde o ruído visual aparece. Em código de domínio, com construtores de valor e retornos de erro, o tipo repetido é a parte que ninguém lê.

O que exatamente muda

A regra nova mexe em duas partes da especificação: a seção de composite literals e as regras de atribuição. Em resumo: onde o tipo esperado é T e T{...} é um literal válido, passa a ser legal escrever apenas {...} . O mesmo vale para contextos em que se espera *T , herdando o comportamento que já existe para []*Point{{1, 2}} .

O que já funcionava hoje:

O que passa a valer em Go 1.28:

Pelas change lists já mescladas no branch de desenvolvimento, o trabalho cobriu literais de struct, chamadas de função, retornos e os contextos em que o alvo tem tipo conhecido — inclusive append . O padrão que mais deve pegar é o retorno de valor zero junto com erro:

Impacto no código existente: nada quebra

Go mantém a promessa de compatibilidade: a mudança só adiciona sintaxe aceita, não reinterpreta a existente. Builds atuais continuam compilando. O ponto de atenção é o inverso — código novo com elisão não compila em módulos cuja diretiva go no go.mod seja anterior a 1.28, porque a linguagem é versionada por módulo. Isso significa:

Aplicações internas : dá para adotar assim que a toolchain 1.28 estiver disponível, subindo a diretiva do módulo.

Bibliotecas públicas e SDKs : precisam esperar. Adotar elisão hoje reduz a faixa de versões suportadas e pode quebrar usuários que ainda buildam com 1.27.

CI : pipelines com go-version: '1.27' vão falhar em qualquer arquivo que use o recurso, mesmo que o desenvolvedor esteja na 1.28 localmente.

Esse tipo de decisão de compatibilidade aparece com frequência em revisões de arquitetura de projetos que mantêm várias stacks em paralelo — é comum ver times avaliando migrações de linguagem junto com Python, Node.js/TypeScript, C#/.NET e bancos relacionais, e a prática que a Maquinaweb costuma aplicar nesses cenários é separar a adoção por módulo e por versão mínima suportada, em vez de padronizar tudo de uma vez.

Riscos e armadilhas

1. Literal sem tipo esconde a estrutura. {0, 0} só é legível se o tipo estiver na mesma linha ou na assinatura da função. Em return de método longo, com Point definido em outro pacote, o leitor precisa subir a tela. Em APIs públicas, o tipo explícito continua sendo documentação gratuita.

2. Ambiguidade sintática não desaparece. Composite literal dentro do cabeçalho de if , for ou switch ainda exige parênteses: if p == (Point{1, 2}) . Com a elisão, não há como escrever if p == {1, 2} — o parser vê um bloco. Nesses lugares, você continua digitando o tipo.

3. Interface não funciona. O alvo precisa ser um tipo composto concreto; var s fmt.Stringer = {...} segue inválido, porque não há como saber qual struct construir. Se o retorno é interface, elisão não ajuda.

4. Ferramental a jusante. gofmt e o parser do go/ast lidam com o nó normalmente, mas geradores de código, linters e regras que reescrevem expressões vão precisar de atualização. Vale acompanhar staticcheck , golangci-lint e geradores antes de transformar elisão em padrão de time.

5. Revisão de código fica subjetiva. Sem regra escrita, metade do time usa User{} e metade usa {} . Defina no guia de estilo onde a elisão é obrigatória (retornos de valor zero com erro), opcional (argumentos curtos) e proibida (structs de configuração com muitos campos).

O que fazer agora

Não refatore nada hoje: a feature está no branch de desenvolvimento e o alvo é a 1.28. O movimento útil neste momento é de preparação:

Leia a proposta #12854 e o rascunho das notas de release para acompanhar mudanças de última hora na regra.

Verifique se o seu pipeline consegue rodar mais de uma versão da toolchain; isso é o que vai permitir testar a 1.28 antes de subir a diretiva do módulo.

Se você mantém bibliotecas, marque mentalmente que elisão é sintaxe de 1.28 — não use em código publicado para consumo amplo.

Separe os pontos do domínio que mais sofrem com repetição ( Span , Money , Page[T] ) e avalie caso a caso.

Se o seu time precisa decidir onde essa mudança entra — ou está avaliando migração de stack, revisão de arquitetura de serviços em Go ou desenvolvimento de um projeto sob medida —, o time da Maquinaweb pode conversar sobre o desenho técnico e o plano de adoção sem compromisso.

Fontes

#Go #Go 1.28 #linguagem #composite literals #inferência de tipo #release
Contato

Bora conversar?

Três campos. A resposta vem no WhatsApp.

Ou escreva para contato@maquinaweb.com.br.

Você vai para o WhatsApp com a mensagem pronta. Sem spam, sem lista.

Seus dados seguem a nossa política de privacidade.