Pointer to interface in method args?

Gist with code

How can I use interface Herbivore instead *Mouse in line 30?

I want to pass to method eatingVictim different structs which implements Herbivore interface, not only Mouse

Let me explain:

First of all in this function:

func (predator Cat) eatingVictim(victim *Mouse) {
fmt.Println(predator.name + "'s eating victim " + victim.name)
predator.hungry = false
victim.alive = false
}

You want to pass Herbivore. This is a bad solution because you will not
use methods from Herbivore interface here. Better approach is to define
another interface.

type Animal interface {
GetName() string
SetAlive(bool)
}

And implement it for Mouse (and Cat if you wish):

func (m *Mouse) GetName() string {
return m.name
}
func (m *Mouse) SetAlive(alive bool) {
m.alive = alive
}

Then change interface Predator to:

type Predator interface {
eatingVictim(victim Animal)
}

and implement it for Cat

func (predator *Cat) eatingVictim(victim Animal) {
fmt.Println(predator.name + "'s eating victim " + victim.GetName())
predator.hungry = false
victim.SetAlive(false)
}

I need to mention that if you want your original structs to
be modified then you need to pass a pointer to struct, not a struct as
receiver argument:

Here Mouse struct will not be modified. Only a copy of it.

func (herbivore Mouse) eatingGrass() {
fmt.Println(herbivore.name + "'s eating a grass.. ^___^")
herbivore.hungry = false
}

And here is the fixed version:

func (herbivore *Mouse) eatingGrass() {
fmt.Println(herbivore.name + "'s eating a grass.. ^___^")
herbivore.hungry = false
}

If you want better explanation for this - then visit
my blog post

The last thing - as best practice - if you used Struct pointer in one of the methods of your
type then all of them should take a pointer to it.

Final solution:

package main
import "fmt"
type Predator interface {
eatingVictim(victim Animal)
}
type Herbivore interface {
eatingGrass()
}
type Animal interface {
GetName() string
SetAlive(bool)
}
type Cat struct {
name   string
hungry bool
alive  bool
}
type Mouse struct {
name   string
hungry bool
alive  bool
}
func (herbivore *Mouse) eatingGrass() {
fmt.Println(herbivore.name + "'s eating a grass.. ^___^")
herbivore.hungry = false
}
func (m *Mouse) GetName() string {
return m.name
}
func (m *Mouse) SetAlive(alive bool) {
m.alive = alive
}
func (predator *Cat) eatingVictim(victim Animal) {
fmt.Println(predator.name + "'s eating victim " + victim.GetName())
predator.hungry = false
victim.SetAlive(false)
}
func main() {
cat := Cat{"cat", true, true}
mouse := Mouse{"mouse", true, true}
fmt.Println(cat)
fmt.Println(mouse)
mouse.eatingGrass()
cat.eatingVictim(&mouse)
fmt.Println(cat)
fmt.Println(mouse)
}

First you need to add a Name() and a SetAlive() method to the interface and make eatingGrass exported:

type Herbivore interface {
Name()string
SetAlive(bool)
EatingGrass()
}

Then you need to implement Name() for mouse:

func (herbivore *Mouse) Name()string {
return Mouse.name
}

Then do the same for SetAlive.

Now you can use the interface:

func (predator Cat) eatingVictim(h Herbivore) {
fmt.Println(predator.name + "'s eating victim " + h.Name())
predator.hungry = false
h.SetAlive(false)
}

Note: You should implement all the functions for the *Mouse. Because when you set some values of the struct you should implement the method for the pointer and not the struct. Otherwise you can have bugs.

When implementing it is also better to define the varibale like this:

func (m *Mouse) Name() string {
return m.name
}