proposal: anonymous struct and array literals for functions

[koblas]

Summary:
Allow for anonymous types for struct and array be passed to functions.

type Options struct {
    Name string
    Age  int
}

func SomeThing(options Options) {
    fmt.Printf("Got options %+v\n", options)
}

func AnotherThing(list []string) {
    fmt.Printf("Got list %v\n", list)
}

func main() {
    SomeThing({Name: "John Smith"})

    AnotherThing({"one", "two"})
}

Motivation:

Presently in go, there is auto typing available on function returns. value := MyFunc(). It would follow that given a known type on a function eg func SomeThing(options Options) that passing a structure that meets the type description required by the function should allow you to avoid presenting the full type name.

If you assign a struct/slice to a variable you would need to present a type.

value := { Name: "John Smith" }  // Not allowed, since it's ambigious

Generally trying to avoid having to write:

   value := module.SomeBigFunction(module.SomeReallyLongType{ .... })

Alternative:

Since having the ability to call functions with similar syntax {} values. The alternative would be to flag it as an anonymous struct or array by adding a struct{ .... } which still allows for the caller to quickly write compatible calls for interfaces without having to add fully qualified type descriptors.

func main() {
    SomeThing(struct{Name: "John Smith"})

    AnotherThing([]{"one", "two"})  // potentially simillary matched with an anon array
}

Cons:

The biggest loss is that you no longer have the explicit type name in the call to the function.

[cespare]

This essentially looks like #12854, which is more fleshed out and has seen a lot of discussion.

[dsnet]

Hi, thank you for the proposal, but this looks to be a duplicate of what's proposed in #12854.

[koblas]

You're right, didn't find that when I was looking.