Currently in Go, the address operator (&) can only be applied to an addressable element (i.e. a variable, pointer indirection, slice indexing, addressable struct fields, and composite literals). However, if you are using numeric, string, or bool literals, the address operator is not supported. This usually forces some awkward workarounds that either use intermediate variables, or boxed values (basic literals wrapped in composite types), or helper functions that return pointers for their passed values.

Proposal

As mentioned earlier, the address operator can be applied to composite literals to automatically return the address of their respective values as illustrated below:

type myT struct{a string}
a := &myT{"A"}
x := &struct{a string; b int}{"A", 12}
y := &[]string{"A","B"}
z := &[1]int{2}

This proposal calls for extending this mechanism so that the address operator could also support numeric, string, and boolean literal operands. To minimize impact on the language, the proposal calls for the reuse of the same lexical format used for composite literals, mainly:

"&" basic_types | bool "{" BasicLit | BoolConstant"}"

The following shows examples of how the address operator would be applied to basic and boolean literal values to automatically return their respective addresses:

t := struct {
    f1 *int
    f2 *string
    f3 *float64
    f4 [2]*int64
    f5 *bool
}{
    f1: &int{12},
    f2: &string{"Hi!"},
    f3: &float64{3.14},
    f4: [2]*int64{&int64{44}, &int64{12}},
    f5: &bool{true},
}

By contrast, one of the ways to do the same thing today requires an intermediate set of variable assignments as shown below:

f1 := 12
f2 := "Hi!"
f3 := float64(3.14)
var a, b int64 = 44, 12
f5 := false

t := struct {
    f1 *int
    f2 *string
    f3 *float64
    f4 [2]*int64
    f5 *bool
}{
    f1: &f1,
    f2: &f2,
    f3: &f3,
    f4: [2]*int64{&a, &b},
    f5: &f5,
}

Another workaround uses a sort of type boxing that declares additional types that can wrap basic values inside corresponding struct values:

type Int struct{Value int}
type String struct {Value string}
type Float64 struct{Value float64}
type Int64 struct{Value int64}
type Bool struct{Value bool}
...
t := struct {
    f1 *Int
    f2 *String
    f3 *Float64
    f4 [2]*Int64
    f5 *Bool
}{
    f1: &Int{12},
    f2: &String{"Hi!"},
    f3: &Float64{3.14},
    f4: [2]*Int64{&Int64{44}, &Int64{12}},
    f5: &Bool{true},
}

Some codebase uses yet another workaround that define a set of additional helper functions to provide the convenience of returning the addresses of their passed values as shown:

func Int(v int) *int {return &v}
func String (v string) *string {return &v}
func Float64(v float64) *float64 {return &v}
func Int64(v int64) *int64 {return &v}
func Bool(v bool) *bool {return &v}

t := struct {
    f1 *int
    f2 *string
    f3 *float64
    f4 [2]*int64
    f5 *bool
}{
    f1: Int(12),
    f2: String("Hi!"),
    f3: Float64(3.14),
    f4: [2]*int64{Int64(44), Int64(12)},
    f5: &Bool(true),
}