Is there a way to elide type of a composite literal by inferring types based on the type parameter of function in go?

type Foo struct {
    a    string
    b    int
}

type Bar[K Foo|string] struct {
    c    K
    d    string
}

func someRandomFunc (x []Bar[Foo], y []Bar[string]) {
    ///do something
}

someRandomFunc([]Bar[Foo]{{Foo{"A", 1}, "a"}, {Foo{"B", 1}, "b"}}, []Bar[string]{{{"C"}, "c"}, {{"D"}, "d"}})

In the above code why isnt go infering type from the function argument? Do I have to prefix each time the custom type? Why can't I do something like below?

someRandomFunc({{{"A", 1}, "a"}, {{"B", 1}, "b"}}, {{{"C"}, "c"}, {{"D"}, "d"}})

Inferring type from the constrained generic type

Go is not inferring the type from the constrained generic type as well (which it does infer if the constrained generic type is a primite types like string but not for custom types).

someRandomFunc([]Bar[Foo]{{{"A", 1}, "a"}, {{"B", 1}, "b"}}, []Bar[string]{{{"C"}, "c"}, {{"D"}, "d"}})

Inferring type from the sibling inside the slice

Go does not even infer the type from the previous sibling inside the slice

someRandomFunc([]Bar[Foo]{{Foo{"A", 1}, "a"}, {{"B", 1}, "b"}, {{"C", 1}, "c"}}, []Bar[string]{{{"D"}, "d"}, {{"E"}, "e"}, {{"F"}, "f"}})

Is any of the above possible with any workaround?

Type elisions in composite literals as of Go 1.19.4 is possible only in case of arrays, slices and maps. For structs type fields are mandatory and cannot be omitted.

Example

1. Arrays and Slices - Possible

type Foo struct {
    a    string
    b    int
}

var a []Foo = []Foo{{"A", 1}, {"B", 2}}

2. Maps - Possible

type Foo struct {
    a    string
    b    int
}

var a Map[string]Foo = Map[string]Foo{"a": {"A", 1}, "b": {"B", 2}}

3. Struct - Not possible

type Foo struct {
    a    string
    b    Bar
}

type Bar struct {
    c    string
    d    int
}

var a []Foo = []Foo{{"A", Bar{"a", 1}}, {"B", Bar{"b", 2}}}

In the above example it can be noted that type field Bar is not omitted. Further since go as of 1.19.4 doesn't support type elision for structs, type elision is not an option whether or not a generic type is constrained or otherwise.