proposal: Go 2: Type switch on slices and maps of objects that match interface

[spekary]

What did you do?

package main

import (
"fmt"
)


type A struct {
	s string
}

func (a A) String() string {
	return "I am " + a.s + "\n"
}


func main() {

	a := []A{{"a"}, {"b"}}
	b := map[string]A{"a":{"a"}, "b":{"b"}}

	var i1, i2 interface{}

	i1 = a
	i2 = b

	switch v := i1.(type) {
	case []fmt.Stringer:
		for _,s := range v {
			fmt.Print(s.String())
		}
	default:
		fmt.Println("Failed")
	}

	switch v2 := i2.(type) {
	case map[string]fmt.Stringer:
		for _,s := range v2 {
			fmt.Print(s.String())
		}
	default:
		fmt.Println("Failed")
	}

}

What did you expect to see?

I am a
I am b
I am a
I am b

What did you see instead?

Failed
Failed

Discussion

I realize this is currently as designed. I also realize there are other related issues around this, including generics, but I think this might be an inexpensive way of achieving a variety of goals.

Since this is within a type switch, there is an understanding with the developer that there is potential performance impacting type juggling going on. By controlling the order of the switch statements, the developer can decide when to ask the compiler to consider a slice or map of objects as to whether the inner object matches an interface.

I also realize that there is a type conversion issue inside of the for statements. A possible solution is that a type assertion in this way might cause the slice or map variable to have an internal indicator that if it is ranged over inside of the case, it will return the asked for interface instead. There are recursion issues here too, but that should be no problem since the asked for interface is inside of the returned type assertion variable, and a recursive type switch would create a new variable. So yes, its complex, but should be doable and quite helpful.

[ianlancetaylor]

In the general case this will require creating a complete copy of the slice or map, in order to convert the values to the desired type. That in turn will cause confusion if the code changes an index. It could also lead to loss of type safety: if a []A is converted to a []fmt.Stringer in a type switch, and the type switch case changes an element of the slice, it could install a new value that is a fmt.Stringer but is not an A. And in fact that might happen by passing the slice to some other function entirely, in a different package. So the only way this could be implemented safely would be to change every assignment to an element of a slice of interface type to check whether the type is valid for the slice, or something like that. We aren't going to do this.