Add:
If my code is

// ConvertFloat64 convert any type to float64 if it can.
func ConvertFloat64(v interface{}) (ret float64, err error) {
	switch val := v.(type) {
	case float64:
		return val, nil
	case float32:
		return float64(val), nil
	case uint:
		return float64(val), nil
	case uint8:
		return float64(val), nil
	case uint16:
		return float64(val), nil
	case uint32:
		return float64(val), nil
	case uint64:
		return float64(val), nil
	case int:
		return float64(val), nil
	case int8:
		return float64(val), nil
	case int16:
		return float64(val), nil
	case int32:
		return float64(val), nil
	case int64:
		return float64(val), nil
	default:
		err = fmt.Errorf("unsupported value to convert to float64,%v", v)
	}
	return
}

error won't occur.

When you use a type switch like

    switch val := v.(type) {

then if the case has multiple types, the type of val is interface{}. And Go does not permit writing float64(val) if val has type interface{}.

It's true that float64(val) can be compiled for every type in the case, but since Go is statically typed that could only be done if the compiler quietly duplicated the case for every type. The language requires that if that is what you want to do, you must do it explicitly.

See https://golang.org/ref/spec#Switch_statements :

The TypeSwitchGuard may include a short variable declaration. When that form is used, the variable is declared at the end of the TypeSwitchCase in the implicit block of each clause. In clauses with a case listing exactly one type, the variable has that type; otherwise, the variable has the type of the expression in the TypeSwitchGuard.