Can Contravariance Solve Go 1.18\'s Generic Type Compatibility Issue in the Pipe Function?

Contravariant Types in Go 1.18 Generics

In Go 1.18, generic types allow for defining functions with types that vary depending on the type arguments. Contravariance, a specific type of variance, allows for functions to accept a wider range of input types while maintaining a well-defined relationship between input and output types.

Pipe Function

The provided Pipe function aims to compose functions that transform values. It expects the output type of the left function to match the input type of the right function. However, in the following example, it fails to compile:

func Pipe[A, T1, T2 any](left func(A) T1, right func(T1) T2) func(A) T2 {
    return func(a A) T2 {
        return right(left(a))
    }
}

func OpenFile(name string) *os.File {
    ...
}

func ReadAll(rdr io.Reader) []byte {
    ...
}

var OpenRead = Pipe(OpenFile, ReadAll)

The compiler complains because T1 is considered to be *os.File even though it's compatible with io.Reader.

Is there a Solution?

Unfortunately, there is no way in Go 1.18 generics to modify the signature of Pipe to enable the desired behavior. Go does not support covariant result types, meaning that the output type of a function cannot vary based on the input type.

Is it a Bug?

The behavior in Go 1.18 is not a bug. It is by design, as explained in the FAQ for Go generics.

Workaround

To address this limitation, a modified version of the Pipe function can be used, but it sacrifices compile-time type safety:

func Pipe[A, T1, T2, T3 any](left func(A) T1, right func(T2) T3) func(A) T3 {
    return func(a A) T3 {
        return right(any(left(a)).(T2))
    }
}

The above is the detailed content of Can Contravariance Solve Go 1.18\'s Generic Type Compatibility Issue in the Pipe Function?. For more information, please follow other related articles on the PHP Chinese website!