How to execute a callback who's type is a generic type constrained with multiple return types?

I'm trying to allow a callback parameter in my function that permits multiple return tuples. To achieve this, I'm using generics to define the parameter type for the callback.

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.
}

Since TranslateFn is constrained to either of those two return types (either Out or (Out, error)), I assumed I would be able to call it.

What I'd like to do is something like the following, however I cannot because I'm unable to use type assertion on the translate argument.

> 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")
}

Without type assertion, how would I go about invoking this callback, or determining which of the generic variations was provided?

Wrap it into an interface first and then do type assertion (or type switch). E.g. 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")
}

As mkopriva's answer suggests, a type switch is an option, but generally speaking, I would advise against allowing both types of, what is essentially, callbacks. Instead I'd just do something like this:

func Get[
    In any,
    Out any,
    TranslateFn func(In) (Out, error),
](
    input In,
    translate TranslateFn,
) (*Out, error) {
    o, err := translate(in)
    if err != nil {
         return nil, err
    }
    return &o, nil
}

Now, if you have a bunch of functions you want to use, but a significant proportion of them don't return an error, you can provide a convenience wrapper function:

func ErrWrap[In any, Out any] (cb func(In) Out) func (In) (Out, error) {
    return func (i In) (Out, error) {
        o := cb(i)
        return o, nil
    }
}

With this, all functions that don't return an error can be neatly wrapped to return an error value (which will simply always be nil).

The benefit is that it simplifies your current Get function, so it's just a lot cleaner, and easier to read/maintain for others (and yourself). Going forwards, it communicates quite clearly that Get expects a callback that returns a value of type Out, and an error, but existing functions (and places they are called) needn't be immediately refactored to account for a second return value, although you should know that all calls to ErrWrap are indicators of technical debt.