Mapping of different types with generics

How to map 2 different types (Car, Bicycle) with one generic mapping function (Map2Vehicle) to a Vehicle type. Car and Bicycle cannot be changed, because it's auto generated code.

package main

import "fmt"

func main() {
	c := Car{Name: "MyCar", Wheels: CarWheels{Count: 4}}
	b := Bicycle{Name: "MyBicycle", Wheels: BicycleWheels{Count: 2}}
	v1 := Map2Vehicle(&c)
	v2 := Map2Vehicle(&b)
	fmt.Println(v1.Name, v2.Name)
}

// ---------------- Car
type Car struct {
	Name   string
	Wheels CarWheels
}

type CarWheels struct {
	Count int
}

func (c *Car) GetName() string      { return c.Name }
func (c *Car) GetWheels() CarWheels { return c.Wheels }
func (w *CarWheels) GetCount() int  { return w.Count }

// ---------------- Bicycle

type Bicycle struct {
	Name   string
	Wheels BicycleWheels
}

type BicycleWheels struct {
	Count int
}

func (b *Bicycle) GetName() string          { return b.Name }
func (b *Bicycle) GetWheels() BicycleWheels { return b.Wheels }
func (w *BicycleWheels) GetCount() int      { return w.Count }

// ---------------- Vehicle

type wheels interface {
	GetCount() int
}

type vehicle[T wheels] interface {
	GetName() string
	GetWheels() T
}

type Vehicle struct {
	Name string
}

func Map2Vehicle[T vehicle[wheels]](v T) *Vehicle {
	return &Vehicle{
		Name: fmt.Sprintf("%s with %d wheels", v.GetName(), v.GetWheels().GetCount()),
	}
}

Error: The code does not work:

cmd/tmp/tmp.go:8:19: *Car does not satisfy vehicle[wheels] (wrong type for method GetWheels)
                have GetWheels() CarWheels
                want GetWheels() wheels
cmd/tmp/tmp.go:9:19: *Bicycle does not satisfy vehicle[wheels] (wrong type for method GetWheels)
                have GetWheels() BicycleWheels
                want GetWheels() wheels

Expected output:

MyCar with 4 wheels MyBicycle with 2 wheels

Any ideas how to solve the problem with golang generics?

First off: CarWheels and BicycleWheels do not implement the wheels interface. This is because your GetCount methods use pointer receivers:

func (w *CarWheels) GetCount() int { return w.Count }
func (w *BicycleWheels) GetCount() int { return w.Count }

thus *CarWheels and *BicycleWheels (pointers to structs) implement the wheels interface, but the structs themselves do not. I'd simply remove the pointer receivers since these structs are very small (effectively just ints) and there's no need to "box" them using pointers (doing so would just incur overhead):

func (w CarWheels) GetCount() int { return w.Count }
func (w BicycleWheels) GetCount() int { return w.Count }

Alternatively, if your real structs are larger, you could of course also make your GetWheels methods return pointers to the wheels rather than the wheels themselves.

Second: Your function has a signature of func Map2Vehicle[T vehicle[wheels]](v T) *Vehicle. This means v must be a vehicle where the GetWheels method has return type wheels, not any return type implementing wheels. The solution to this issue is to make GetWheels functions return the abstract wheels type rather than the specific types:

func (c *Car) GetWheels() wheels { return c.Wheels }
func (b *Bicycle) GetWheels() wheels { return b.Wheels }

If you do this, your code will run as expected.

Alternatively, if you want to keep the specific types, you'll have to make the wheels a second generic parameter of the function:

func Map2Vehicle[W wheels, T vehicle[W]](v T) *Vehicle

Go will be unable to infer W (it seems generic type inference doesn't nest), so you have to make the type of wheels explicit at the call site now (it can still infer the type of the vehicle however):

v1 := Map2Vehicle[CarWheels](&c)
v2 := Map2Vehicle[BicycleWheels](&b)

If I were to refactor this, I would eliminate the generics entirely by having the GetWheels method return the wheels interface type; then Map2Vehicle can just operate on any vehicle, and vehicle doesn't need to be generic:

type vehicle interface {
    GetName() string
    GetWheels() wheels
}

func Map2Vehicle(v vehicle) *Vehicle {
    return &Vehicle{
        Name: fmt.Sprintf("%s with %d wheels", v.GetName(), v.GetWheels().GetCount()),
    }
}

Why not create two values of different types, a Car and a Bicycle, then use the Map2Vehicle function to map each value to a Vehicle type?

Playground Link : https://play.golang.com/p/lPFoFEsjIeD

package main
import "fmt"
func main() {
c := Car{Name: "MyCar", Wheels: CarWheels{Count: 4}}
b := Bicycle{Name: "MyBicycle", Wheels: BicycleWheels{Count: 2}}
v1 := Map2Car(c)
v2 := Map2Bicycle(b)
fmt.Println(v1, v2)
}
// ---------------- Car
type Car struct {
Name   string
Wheels CarWheels
}
type CarWheels struct {
Count int
}
func (c *Car) GetName() string      { return c.Name }
func (c *Car) GetWheels() CarWheels { return c.Wheels }
func (w *CarWheels) GetCount() int  { return w.Count }
// ---------------- Bicycle
type Bicycle struct {
Name   string
Wheels BicycleWheels
}
type BicycleWheels struct {
Count int
}
func (b *Bicycle) GetName() string          { return b.Name }
func (b *Bicycle) GetWheels() BicycleWheels { return b.Wheels }
func (w *BicycleWheels) GetCount() int      { return w.Count }
// ---------------- Vehicle
type Vehicle struct {
Name string
}
func Map2Car(c Car) *Vehicle {
return &Vehicle{
Name: fmt.Sprintf("%s with %d wheels", c.GetName(), c.GetWheels()),
}
}
func Map2Bicycle(b Bicycle) *Vehicle {
return &Vehicle{
Name: fmt.Sprintf("%s with %d wheels", b.GetName(), b.GetWheels()),
}
}

output:

you're trying to use generics in Go to map different types (Car and Bicycle) to a common Vehicle type. However, you're running into an error because the types Car and Bicycle have different implementations for the GetWheels() method.

To solve this problem, you can modify your code to use an interface instead of a concrete type for the Wheels field in both Car and Bicycle structs. By doing so, you can define a single implementation of GetWheels() that satisfies the wheels interface for both CarWheels and BicycleWheels. Here's an updated version of your code:

package main

import "fmt"

// ------- Car
type Car struct {
    Name   string
    Wheels wheels // Use interface instead of concrete type
}

type CarWheels struct {
    Count int
}

func (c *Car) GetName() string      { return c.Name }
func (c *Car) GetWheels() wheels    { return c.Wheels }
func (w *CarWheels) GetCount() int  { return w.Count }

// ------- Bicycle
type Bicycle struct {
    Name   string
    Wheels wheels // Use interface instead of concrete type
}

type BicycleWheels struct {
    Count int
}

func (b *Bicycle) GetName() string          { return b.Name }
func (b *Bicycle) GetWheels() wheels        { return b.Wheels }
func (w *BicycleWheels) GetCount() int      { return w.Count }

// ------- Common Interfaces -------
type wheels interface {
    GetCount() int
}

type vehicle interface {
    GetName() string
    GetWheels() wheels
}

// ------- Vehicle
type Vehicle struct {
    Name string
}

func Map2Vehicle(v vehicle) *Vehicle {
    return &Vehicle{
        Name: fmt.Sprintf("%s with %d wheels", v.GetName(), v.GetWheels().GetCount()),
    }
}

func main() {
    c := Car{Name: "MyCar", Wheels: &CarWheels{Count: 4}} // Pass a pointer to CarWheels
    b := Bicycle{Name: "MyBicycle", Wheels: &BicycleWheels{Count: 2}} // Pass a pointer to BicycleWheels
    
    v1 := Map2Vehicle(&c)
    v2 := Map2Vehicle(&b)
    fmt.Println(v1.Name, v2.Name)
}

Now, the code should compile and produce the output you expect:

MyCar with 4 wheels MyBicycle with 2 wheels