Why Can't I Pass a `func(int)` to a Function Expecting `func(interface{})` in Go?

Type func with Interface Parameter Incompatible: Understanding Variance

In Go, encountering the "cannot use a (type func(int)) as type myfunc in argument to b" error when invoking a function with an interface parameter can be perplexing. This issue arises due to the concept of variance in type systems.

Go's interfaces do not exhibit variance, meaning that an interface does not behave covariantly like in some other programming languages. When a type x implements an interface ii, it does not imply that func(x) implements func(ii).

In the provided example, the error occurs because func(int) is incompatible with func(interface{}), despite int being assignable to an interface{}. This incompatibility arises from the fact that interfaces do not behave covariantly in Go.

To address this issue, you can pass func(int) into a function that expects interface{}, as demonstrated in the following example:

package main

import "fmt"

func foo(x interface{}) {
    fmt.Println("foo", x)
}

func add2(n int) int {
    return n + 2
}

func main() {
    foo(add2)
}

This works because func(int)int implements interface{}, effectively "widening" the type to a more generic interface type.

For further clarification, refer to the provided Wikipedia article on variance and the linked blog post that explores variance in various programming languages, particularly those supporting inheritance.

The above is the detailed content of Why Can't I Pass a `func(int)` to a Function Expecting `func(interface{})` in Go?. For more information, please follow other related articles on the PHP Chinese website!