Convert type T to type U in an identity function

With the given type signature below, is there a way to do something similar to below?

func Transform[T, U any](item T) U {
	return item
}

The code above gives the following error:

cannot use item (variable of type T constrained by any) as U value in return 
statement

I am unable to use the type signature above, as I am essentially trying to make an optional transform method that sometimes will need to convert from T to U, but sometimes just return itself. A more detailed example of the use case is shown below.

type SomeStruct[T, U any] struct {
	Transform func(T) U
}

func (s SomeStruct[T, U]) Transform(elem T) (U) {
	if s.Transform != nil {
		return s.Transform(elem)
	}
	return elem
}

Is there a way to create a Transform function that sometimes conditionally just returns itself?

You can make your code snippet work:

func Transform[T, U any](item T) U {
	return any(item).(U)
}

But the code will fail with a panic if U is not assertion-compatible with the actual type of item:

This will panic:

fmt.Println(Transform[string, int]("foo"))

// Output: panic: interface conversion: interface {} is string, not int

This succeeds without panic, because bytes.Buffer is implements both the io.Reader and io.Writer interface:

b := &bytes.Buffer{}
_ = Transform[io.Writer, io.Reader](b)

So, it's possible to do what you want. But I'm not sure how useful it is, as fails at runtime of the actual argument isn't compatible with U.

You can't return T if your function is defined to return U. Even if you assert T to U, the function is still returning U.

If you really want to return exactly either T or U, you need to declare the return type as any:

func (s SomeStruct[T, U]) Transform(elem T) any { /* ... */ }

...which gives up static typing; or you could use a helper "either" type:

type Either[T, U any] struct {
	value any
}

// Either methods

func (s SomeStruct[T, U]) Transform(elem T) Either[T, U] {
	if s.transform == nil {
		return Either[T, U]{elem}
	}
	return Either[T, U]{s.transform(elem)}
}

See how to use it in this playground.

<hr>

Alternatives will deviate from your stated goal. One is to actually assert T to U, though you must be aware that this returns U, not T, even if T's value is assignable to U:

func (s SomeStruct[T, U]) Transform(elem T) U {
	if s.transform == nil {
		if u, ok := any(elem).(U); ok {
			return u
		}
		return *new(U) // U's zero value if elem assertion fails
	}
	return s.transform(elem)
}

You must use an assertion because both type parameters T and U are constrained by any, so there's (rightfully) no other way to express convertibility between the two. The comma-ok idiom helps avoid run-time panics.

Or you can return (U, error) instead, which is, generally, the reasonable thing to do:

func (s SomeStruct[T, U]) Transform(elem T) (u U, err error) {
	if s.transform == nil {
        err = errors.New("transform function not set")
		return 
	}
	u = s.transform(elem)
    return
}

Playground: https://go.dev/play/p/GKLRmKKWxlP