Wie führe ich einen Rückruf vom Typ „Generic' aus, der mehreren Rückgabetypen unterliegt?

Frageninhalt

Ich versuche, in meiner Funktion einen Rückrufparameter zuzulassen, der mehrere Rückgabetupel ermöglicht. Um dies zu erreichen, verwende ich Generika, um die Parametertypen des Rückrufs zu definieren.

func get[
    in any,
    out any,
    translatefn func(in) out | func(in) (out, error),
](
    input in,
    translate translatefn,
) (*out, error) {
    // call translate to convert the input to the output.
    // if translate is an erroring function, make sure the error is
    // forwarded to the response of this function.
}

Da „translatefn“ auf einen dieser beiden Rückgabetypen (out 或 (out, error)) beschränkt ist, dachte ich, ich könnte es aufrufen.

Was ich tun möchte, ist etwa Folgendes, kann es aber nicht, da ich keine Typzusicherung für den Parameter translate verwenden kann.

invalid operation: cannot use type assertion on type parameter value translate (variable of type translatefn constrained by func(in) out|func(in) (out, error))

func Get[
    In any,
    Out any,
    TranslateFn func(In) Out | func(In) (Out, error),
](
    input In,
    translate TranslateFn,
) (*Out, error) {
    if erroringFn, isErroringTranslateFn := translate.(func(In) (Out, error)); isErroringTranslateFn {
        out, err := erroringFn(input)
        if err != nil {
            return nil, err
        }
        return &out, nil
    }

    if nonErroringFn, isNonErroringTranslateFn := translate.(func(In) Out); isNonErroringTranslateFn {
        out, err := nonErroringFn(input)
        if err != nil {
            return nil, err
        }
        return &out, nil
    }

    panic("translate function must be either func(In) (Out, error) or func(In) Out")
}

Wie würde ich diesen Rückruf ohne Typzusicherungen aufrufen oder feststellen, welche allgemeinen Varianten bereitgestellt werden?

Workaround

Wickeln Sie es zuerst in eine Schnittstelle und führen Sie dann die Typzusicherung (oder den Typwechsel) durch. Zum Beispiel. any(v).(t)

func Get[
    In any,
    Out any,
    TranslateFn func(In) Out | func(In) (Out, error),
](
    input In,
    translate TranslateFn,
) (*Out, error) {
    switch f := any(translate).(type) {
    case func(In) (Out, error):
        out, err := f(input)
        if err != nil {
            return nil, err
        }
        return &out, nil
    case func(In) Out:
        out := f(input)
        return &out, nil
    }

    panic("shouldn't happen")
}

Das obige ist der detaillierte Inhalt vonWie führe ich einen Rückruf vom Typ „Generic' aus, der mehreren Rückgabetypen unterliegt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!