将结构组合传递给 function

Question

Need some help understanding golang.

Coming from C++ using a base class this is trivial. In Go, using struct composition, which works fine up to the point where I need to have function that take the "Base" struct. I understand that it's not truly a base class, but when comes to assigning values to the fields of the base class from the derived, it works fine. But I cannot pass Dog into a function that takes Wolf .

package main
    
import "fmt"
    
type Wolf struct {
    ID     string
    Schema int
}
    
type Dog struct {
    Wolf
}
    
type Dingo struct {
    Wolf
}
    
func processWolf(wolf Wolf) {
    fmt.Println(wolf.ID, wolf.Schema)
}
    
func main() {
    porthos := Dog{}
    porthos.ID = "Porthos"  // works fine able to set field of Wolf
    porthos.Schema = 1      // works fine
    
    aussie := Dingo{}
    aussie.ID = "Aussie"  // works fine
    aussie.Schema = 1     // works fine
    
    fmt.Println(porthos.ID, porthos.Schema)
    fmt.Println(aussie.ID, aussie.Schema)

    processWolf(porthos) << fails here
    processWolf(aussie) << fails here
    
}

Answer 1

The processWolf function takes a Wolf argument, so you have to pass a Wolf . Since both structures have Wolf embedded in them, you can do:

processWolf(porthos.Wolf) 
processWolf(aussie.Wolf) 

because when you embed Wolf into Dog , Dog gets all the methods Wolf has, plus Dog has a member called Wolf .

Answer 2

When i originally posted the question I tried to simplify the problem statement, perhaps too much and Mr. Serdar was kind enough to answer the question, but did not help with my problem. After more digging into the lang of gophers, i came across a solution which used interface{} to solve this. I adapted it my mongo code and it is working, though I might say it does not look as simple as with other language passing references around.

// FindAll retrieves one object from the collection
func FindAll(collection *mongo.Collection, filter bson.M, resultSet interface{}) error {

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Seconds)
    defer cancel()

    cursor, err := collection.Find(ctx, filter)
    if err != nil {
        return err
    }

    defer cursor.Close(ctx)

    objects := reflect.ValueOf(resultSet).Elem()

    for cursor.Next(ctx) {

        obj := reflect.New(objects.Type().Elem())

        err = cursor.Decode(obj.Interface())

        if err != nil {
            log.Panicln("FindAll:", err.Error())
            // assuming that an interface is out of alignment and need to know ASAP.
        }

        objects = reflect.Append(objects, obj.Elem())
    }

    reflect.ValueOf(resultSet).Elem().Set(objects)

    return nil
}

and then call it using

    var dogs []Dog
    if err := database.FindAll(houseCollection, bson.M{}, &dogs); err != nil {
        return nil, err
    }

    println(dogs)

    var dingos []Dingo
    if err := database.FindAll(houseCollection, bson.M{}, &dingos); err != nil {
        return nil, err
    }

    println(dingos)

Without Dog and Dingo having to be related with a base class. But I really felt that the designers of Golang made some weird turns that I have yet to understand. Though having fun chasing Gophers.