[go-nuts] Iterating over slices of different types and calling a method with the same return type and arguments - failing to avoid verbosity in Go

I am trying to reduce the amount of code duplication where I iterate
through a number of slices of different types, but where the same method is
called for each type.
I've constructed a (much shorter and simpler) example to illustrate.

Assume we have the following types defined:

type ComputerSystem struct { ... }
type BiologicalSystem struct { ... }
type PlumbingSystem struct { ... }
type AllSystems struct {
ComputerSystems []*ComputerSystem
BiologicalSystems []*BiologicalSystem
PlumbingSystems []*PlumbingSystem
}


And each of the "System" types have an "IsGo" method defined with the same
arguments and return type. I.e.:

func (s *ComputerSystem) IsGo() bool { ... }
func (s *BiologicalSystem) IsGo() bool { ... }
func (s *PlumbingSystem) IsGo() bool { ... }

I have written a method that checks if an AllSystems instance returns
false for any of it's subsystems:

func (allSystems *AllSystems) AreGo() bool {
for _, system := range(allSystems.ComputerSystems) {
if !system.IsGo() {
return false
}
}
for _, system := range(allSystems.BiologicalSystems) {
if !system.IsGo() {
return false
}
}
for _, system := range(allSystems.PlumbingSystems) {
if !system.IsGo() {
return false
}
}
return true
}

The code includes an identical for loop for each sub system slice.

Is there a way to DRY this up?