How to assign or return a generic T subject to a union?

php Xiaobian Yuzai brings you an article on how to assign or return a general T subject to union constraints. When writing PHP code, sometimes we need to define a data type, which can be a combination of multiple different types. This is the union type. However, we may encounter some confusion when we try to assign or return such a union-constrained generic T. This article will give you a detailed answer on how to deal with this problem, allowing you to better apply the general T of the union type.

Question content

In other words, how to implement a type-specific solution for different types in a union type set?

Given the following code...

type fieldtype interface {
    string | int
}

type field[t fieldtype] struct {
    name         string
    defaultvalue t
}

func newfield[t fieldtype](name string, defaultvalue t) *field[t] {
    return &field[t]{
        name:         name,
        defaultvalue: defaultvalue,
    }
}

func (f *field[t]) name() string {
    return f.name
}

func (f *field[t]) get() (t, error) {
    value, ok := os.lookupenv(f.name)
    if !ok {
        return f.defaultvalue, nil
    }
    return value, nil
}

Compiler shows error:

field.go:37:9: cannot use value (variable of type string) as type t in return statement

Is there a way to provide implementations for all possible fieldtypes?

like...

func (f *Field[string]) Get() (string, error) {
    value, ok := os.LookupEnv(f.name)
    if !ok {
        return f.defaultValue, nil
    }
    return value, nil
}

func (f *Field[int]) Get() (int, error) {
    raw, ok := os.LookupEnv(f.name)
    if !ok {
        return f.defaultValue, nil
    }
    value, err := strconv.ParseInt(raw, 10, 64)
    if err != nil {
        return *new(T), err
    }
    return int(value), nil
}

Any tips are welcome.

Solution

This error occurs because operations involving type parameters (including assignment and return) must be valid for all types in their type set. In the case of string | int, there is no common operation to initialize their values ​​from strings.

But you still have a few options:

t

You use a field of generic type t in a type switch and temporarily set the value of the specific type into the interface {}/any. Then type the interface assertion back into t to return it. Note that this assertion is unchecked, so if for some reason ret holds something that is not part of the t type set, a panic may occur. Of course you can check it with comma -ok, but it's still a runtime assertion:

func (f *field[t]) get() (t, error) {
    value, ok := os.lookupenv(f.name)
    if !ok {
        return f.defaultvalue, nil
    }
    var ret any
    switch any(f.defaultvalue).(type) {
    case string:
        ret = value

    case int:
        // don't actually ignore errors
        i, _ := strconv.parseint(value, 10, 64)
        ret = int(i)
    }
    return ret.(t), nil
}

*t

You can further simplify the above code and get rid of the empty interface. In this example, you get the address of a variable of type t and open the pointer type. This is fully type checked at compile time:

func (f *Field[T]) Get() (T, error) {
    value, ok := env[f.name]
    if !ok {
        return f.defaultValue, nil
    }

    var ret T
    switch p := any(&ret).(type) {
    case *string:
        *p = value

    case *int:
        i, _ := strconv.ParseInt(value, 10, 64)
        *p = int(i)
    }
    // ret has the zero value if no case matches
    return ret, nil
}

Note that in both cases you must convert the t value to interface{}/any for use in the type switch it. You cannot type switch directly on t.

Playground with simulation os.lookupenv map: //m.sbmmt.com/link/498bce62bd2bda584246701fa0166482

The above is the detailed content of How to assign or return a generic T subject to a union?. For more information, please follow other related articles on the PHP Chinese website!