Embedded types and polymorphism with structs

I'm creating an API, and I have two different structs for JSON responses; one for single records and one for collection of records:

type Model struct {
  Id uint
}

type Collection struct {
  Records []Model
}

A Model is just a struct representation of database data (for say, a User), and a Collection is a collection of models.

The issue is that there will be separate structs that embed the Model type, like so:

type User struct {
	*Model
	Name string
}

And since a User doesn't satisfy the Model type, I can't append it to the Collection struct like this:

user := User{&Model{1}, "Jon"}
uc := &Collection{[]User{user}}

How can I make the Records struct accept struct types that implement Model?

You have two options:

• Make another collection type
• Use interfaces instead

Implementing separate collections like UserCollection, BarCollection, FooCollection is an option if you do not have too many foos and bars.

The other way is to use either the generic empty interface type interface{} which will hold values of any type (since every instance of every type satisfies the empty interface):

type Collection struct {
    Records []interface{}
}

This has a number of drawbacks such as that you have to do a type assertion every time you access the Records field, that you can put everything in there by mistake and that you have to use reflection to do most manipulations.

The better way to use interfaces would be to implement a model interface and let every type that is a model implement the interface:

type Model interface {
    ImplementsModel()
}

type BaseModel struct {
    Id uint
}

func (b *BaseModel) ImplementsModel() {}

type User struct {
    *BaseModel
    Name string
}

type Collection struct {
    Records []Model
}

Of course you can remove the ImplementsModel dummy method once you have meaningful methods. This dummy method is just there to distinguish the interface from the empty interface so that you cannot put integer values or strings in place of actual models into the collection.

Model struct is not a type User struct.
User can't behave Model even if embedded it.

This case, you can use interface like below.
http://play.golang.org/p/Hh0zIT9yFC

<pre>
package main

import "fmt"

type Model interface {
    GetID() uint
}

type BaseModel struct {
	Id uint
}

func (m BaseModel) GetID() uint {
    return m.Id
}

type Collection struct {
    Records []Model
}

type User struct {
    *BaseModel
    Name string
}

func (u User) GetName() string {
    return u.Name
}

func main() {
    user := User{&BaseModel{1}, "Jon"}
    uc := &Collection{[]Model{user}}
    u := uc.Records[0].(User)
    fmt.Println(u.GetID())
    fmt.Println(u.GetName())
}

</pre>