proposal: Go 2: allow literal values without preceding literal types

[pcostanza]

In many cases, it is already clear from the context what type a literal value should be, so it would be convenient to allow for dropping the requirement to explicitly repeat the literal type. For example, in the following code, currently the literal type has to be repeated.

var v someStruct
v = someStruct{x: 1, y: 2, z: 3}

This proposal suggests that the last line could be written as follows:

v = {x: 1, y: 2, z: 3}

This in itself is not a major improvement for such simple cases. However, a particular use case I have in mind that this would enable is what in other languages is provided through keyword parameters. Here is an example to illustrate the use case:

func FormatFloat(f float64, opt struct {fmt byte; prec, bitSize int;}) string {
   fmt := byte(‘g’) // default value
   if opt.fmt != 0 {
      fmt = opt.fmt
   }
   prec := -1 // default value
   if opt.prec != 0 {
      prec = op.prec
   }
   bitSize = 64 // default value
   if opt.bitSize != 0 {
      bitSize = opt.bitSize
   }
   return strconv.FormatFloat(f, fmt, prec, bitSize)
}

In this example, checks against default 0 values are included to test whether a ‘keyword’ parameter was provided at the call site or not. This function can now be used as follows:

FormatFloat(3.14, {}) // use default options
FormatFloat(2.78, {fmt: ‘e’, bitSize: 32}) // deviate from some default options

Keyword parameters are very useful in other languages (IMHO), and dropping literal types from literal values if the context allows for it would add something very close without adding any extra features to the language.

[mvdan]

This seems related to #21496. Though that is eliding types that are redundant within a single expression, such as nested struct types. Your proposal would go further, and infer context from an entire statement, as far as I understand.

[pcostanza]

@mvdan Indeed.

[ianlancetaylor]

This proposal needs to spell out precisely when types may be elided.

[jimmyfrasche]

This appears to be a duplicate of #12854

[ALTree]

Yes, this is a dup of #12854, there's even the same example for function calls

func Foo(args struct {
  A, B, C int
}) { ... }


Foo({A: 1, B: 2, C: 3})

closing here in favour of the old thread.