Hi there. I *partly* understand how type switch works. What I don’t understand is why I cannot treat the variable of the checked type as… well, as a variable of the checked type. Sorry, I know how it sounds, so let me show you an example. Consider this simple one, just to make the point, not to use it; the function `Sum()`

here aims to calculate a sum of a slice, irrespective whether it’s a slice of `float64`

s or `int`

s. (Once more, I do not need such a function, I just want to understand why type switch works that way.)

```
package main
import (
"fmt"
)
func Sum(X interface{}) interface{} {
switch X.(type) {
case []int:
sum := 0
for _, v := range X {
sum += v
}
return sum
case []float64:
sum := float64(0)
for _, v := range X {
sum += v
}
return sum
default:
return 0
}
}
func main() {
fmt.Println(Sum([]int{0, 1}))
}
```

This does not work, since `X`

is still treated as of `interface{}`

type even though `switch`

checks the type, and in our case it sees that the type is `[]int`

.

This basically means that I can check the type, but I cannot treat `X`

as a variable of this type, right? Is there a way to get around this? I understand Go will soon get generics, and this will be the solution, but I hoped an approach similar to the above one could work. Since it does not, I am afraid type switch is not as useful as I initially thought. Or maybe it is, but I simply do not know how to do it?