How can I (or should I) use Go interfaces for picking one of two packages?

OK, I'm not quite getting it....

I have 2 modules I crafted with identical functions (in different files of course):

package mod1
func MyFunc() string {
   return "mod1.Myfunc"
}
func Func2() string {
   return "mod1.Func2"
}

package mod2
func MyFunc() string {
  return "mod2.MyFunc"
}
func Func2() string {
   return "mod2.Func2"
}

I have an interface defined correctly, (I think) in a third package:

package types

type MyType interface {
  MyFunc() string
  Func2() string
}

I have code which can pick whether I want to use mod1 or mod2, but I'm not quite understanding what I should have this code return:

func mypicker() ????{

}

Then in main, I want to somehow call either mod1.MyFunc() or mod2.MyFunc() based on
mypicker, without knowing which it is.... something like this:

func main() {
  p := mypicker()
  fmt.Print(p.MyFunc())
  // and later
  fmt.Print(p.Func2())
}

I read that interfaces are like void *, but clearly I'm not getting the complete picture.
Pointers to docs, code, anything useful would be great.

You have to be careful with terminology. Go modules and Go packages are very different, even though both can be contained by directories. Basically, a directory is a package if it has at least one Go file in it and no go.mod file. If a directory has a go.mod file in it then it's recognized as a module. Generally, a whole project can be a single module with the go.mod file at the root of the project and that's sufficient. Assuming this is your case, move forward thinking that every sub-directory is just a package within that single module.

An interface doesn't really have to do with modules or packages, it has to do with types. The reason being is that an interface defines behavior, meaning it defines what methods are required for a type to accurately implement that interface. In your case, you defined both functions declared in your interface BUT they are NOT METHODS because they are top-level functions only attached to the package. In order for a function to be a method, it must be "attached" to a type. Then, that type becomes a valid implementation of that interface.

This...

package mod1
func MyFunc() string {
   return "mod1.Myfunc"
}
func Func2() string {
   return "mod1.Func2"
}

Needs to become this...

package mod1
type MyTypeImpl struct {}
func (m MyTypeImpl) MyFunc() string {
   return "mod1.Myfunc"
}
func (m MyTypeImpl) Func2() string {
   return "mod1.Func2"
}

The naming could be improved greatly but the point is that the above function declaration syntax is how you "attach" a function to a type, making it a method, which allows that MyTypeImpl struct to now be a valid implementation of your MyType interface.

Now you can call the interface methods without regards to which underlying type is actually the implementation:

var iType MyType
iType = MyTypeImpl{}
iType.MyFunc()

Notice that in that last line, it does not matter that we used MyTypeImpl to implement the interface. Once the implementation is assigned to a variable with the interface type, we just work with the interface and forget the underlying implementation. When we call iType.MyFunc(), Go will call the proper method from the underlying implementation.

If we had 100 different structs that implemented the MyType interface as MyTypeImpl does, they could all work for the right side of that iType = MyTypeImpl{} line. That's the point of an interface, to define it once and then use it without regard to what underlying struct is actually implementing it.

Interfaces should be used with types, not just plain functions. You can start by reading the Tour of Go sequence on interfaces. Here's an example close to your question's original code:

Given the interface:

type MyType interface {
  MyFunc() string
  Func2() string
}

You'd have a type:

type MyType1 struct{}

func (mt MyType1) MyFunc() string {
  return "MyType1.MyFunc"
}


func (mt MyType1) Func2() string {
  return "MyType1.Func2"
}

And similarly:

type MyType2 struct{}

func (mt MyType2) MyFunc() string {
  return "MyType2.MyFunc"
}


func (mt MyType2) Func2() string {
  return "MyType2.Func2"
}

And now, if you have some function that takes your MyType interface:

func Foo(m MyType) {
  fmt.Println(m.Func2())
  fmt.Println(m.MyFunc())
}

You could call it with either of your types that implements that interface:

m1 := MyType1{}
Foo(m1)
m2 := MyType2{}
Foo(m2)

Here's a Go Playground link where you can try this in action.

As for "picking a type", perhaps you mean something like this:

var mi MyType
if (... some condition ...) {
	mi = m1
} else {
    mi = m2
}

// Now you can do with mi whatever its interfaces permits,
// like calling mi.Func2(), etc.

Regarding the "picking one of two packages" part of the question:

Interfaces are implemented by types; they're orthogonal to packages and modules. In other words, an interface and types that implement it can all be in the same package, or in different packages, or in different modules.