Slices can be initialized with a brace-bound, comma separated list of literals along with the type preceding the braces:

A := []string{"a", "b", "c"}
var Y = []string{"x", "y", "z"}
L := []int{1, 2, 3}

Based on the feedback in #12854, I propose users be able to omit the type on slices of basic types as an intermediate step. The code above may then be written as:

A := {"a", "b", "c"}
var Y = {"x", "y", "z"}
L := {1, 2, 3}
var Y2 []int = {9, 8, 7} // new way of declaring slices

It is my belief that issue #12854 is too great of a step in the right direction and the consequences of eliding many types could cause readability issues, as were discussed. I have deliberately excluded map and struct types from this proposal since they were a source of issues. By reducing the cases in which types may be elided we preserve one of the greatest strengths of Go: it's readability.

It is my argument that this does not impact the readability negatively since it only elides basic types. Whenever this syntax is seen in the wild it can easily be deduced to be one of the 6 "inferrable" basic types.

Some possible effects of the change

Casting types with underlying basic type:

import "example.org/pkg
// ...
type foo []int
c := foo({1, 2, 3})
d := pkg.Bar({"a", "c", "d"})

Go-time's idea on using gofmt to allow users to elide types

A while ago issue #12854 was discussed on the go-time podcast and there was a suggestion type eliding could be used by the programmer and when gofmt was run, it would add the type by itself. This could even be used as a fix in case type elision gets out of hand in the future and gophers agree we prefer to read typed composite literals.