In Go, I want to understand some design choices in the type switch. The following example works as expected:

package main

import "fmt"

func abs[T int | float64](a T) T {
    if a >= 0 {
        return a
    }
    return -a
}

func main() {
    a := -1.1
    switch b := any(a).(type) {
    case int:
        fmt.Println(abs(b))
    case float64:
        fmt.Println(abs(b))
    }
}

However, this similar example does not work:

package main

import "fmt"

func abs[T int | float64](a T) T {
    if a >= 0 {
        return a
    }
    return -a
}

func main() {
    a := -1.1
    switch b := any(a).(type) {
    case int, float64:
        // not working because b keeps the type of a
        fmt.Println(abs(b))
    }
}

I understand that this behavior is expected according to the specification, but why is it designed this way? Specifically, why isn’t the following:

case T1, T2, ...:
// some code

equivalent to:

case T1:
// some code
case T2:
// some code (the same)
...

What is the reasoning behind this design choice in Go’s type switch?