Golang polymorphic parameters and returns

Say I have functions:

func ToModelList(cats *[]*Cat) *[]*CatModel {
    list := *cats
    newModelList := []*CatModel{}
    for i := range list {
        obj := obj[i]
        newModelList = append(newModelList, obj.ToModel())
    }
    return &newModelList
}

func ToModelList(dogs *[]*Dog) *[]*DogModel {
    list := *dogs
    newModelList := []*DogModel{}
    for i := range list {
        obj := obj[i]
        newModelList = append(newModelList, obj.ToModel())
    }
    return &newModelList
}

Is there a way to combine those two so I can do something like

func ToModelList(objs *[]*interface{}) *[]*interface{} {
    list := *objs
    // figure out what type struct type objs/list are
    newModelList := []*interface{}
    // type cast newModelList to the correct array struct type
    for i := range list {
        obj := obj[i]
        // type cast obj based on objs's type
        newModelList = append(newModelList, obj.ToModel())
    }
    return &newModelList
}

First, slices are already a reference, unless you need to change the slice itself, you do not need to pass it as a pointer.
Second, an interface{} can be regardless an object or a pointer to an object. You do not need to have *interface{}.

I am not sure what you are trying to achieve but you could do something like this:

package main
// Interface for Cat, Dog
type Object interface {
ToModel() Model
}
// Interface for CatModel, DogModel
type Model interface {
Name() string
}
type Cat struct {
name string
}
func (c *Cat) ToModel() Model {
return &CatModel{
cat: c,
}
}
type CatModel struct {
cat *Cat
}
func (c *CatModel) Name() string {
return c.cat.name
}
type Dog struct {
name string
}
func (d *Dog) ToModel() Model {
return &DogModel{
dog: d,
}
}
type DogModel struct {
dog *Dog
}
func (d *DogModel) Name() string {
return d.dog.name
}
func ToModelList(objs []Object) []Model {
newModelList := []Model{}
for _, obj := range objs {
newModelList = append(newModelList, obj.ToModel())
}
return newModelList
}
func main() {
cats := []Object{
&Cat{name: "felix"},
&Cat{name: "leo"},
&Dog{name: "octave"},
}
modelList := ToModelList(cats)
for _, model := range modelList {
println(model.Name())
}
}

You define interfaces for your Cat, Dogs etc and for your Model. Then you implement them as you want and it is pretty straight forward to do ToModelList().

you can make *CatModel and *DogModel both implement type PetModel {} interface, and just return []Pet in function signature.

func (cats []*Cat) []PetModel {
...
return []*CatModel {...}
}
func (dogs []*Dog) []PetModel {
...
return []*DogModel {...}
}

BTW: return a pointer of a slice in golang is useless.

If you strip away redundant assignments, and unnecessary pointers-to-slices, you'll find you have little code left, and duplicating it for each of your model types doesn't look so bad.

func CatsToCatModels(cats []*Cat) []*CatModel {
var result []*CatModel
for _, cat := range cats {
result = append(result, cat.ToModel())
}
return result
}

Unless this code is used in a lot of places I'd also consider just inlining it, since it's trivial code and only 4 lines when inlined.

Yes, you can replace all the types with interface{} and make the code generic, but I don't think it's a good tradeoff here.