How to limit interface{} for specific types

I am using Go and I have a factory function that returns different types of objects, depending on a requested identifier:

func NewObject(id string) interface{} {
    switch id {
    case "truck":
        return Truck{}
    case "car":
        return Car{}
    ....
    }
}

Here are the respective struct types:

type Truck struct {
    Foo string
}

type Car struct {
    Bar string
}

As you can see, Truck and Car don't have anything in common. The problem arises from the fact that I now have to deal with the too broad type interface{} when calling NewObject(..). I know there are generics, but this would require to keep a list of all supported types in the type constraints that would complicate things in my code base.

Basically I am looking for a way on how to use inheritance here which Go of course doesn't support. What would be the alternative?

NewObject(..) function can be implemented with the support of generics. You don't need to keep a list of all supported types in the type constraints.

func NewObject[T any](id string) T {
 var vehicle any

 switch id {

 case "truck":
  vehicle = Truck{
   Foo: "foo",
  }
 case "car":
  vehicle = Car{
   Bar: "bar",
  }
 }

 if val, ok := vehicle.(T); ok {
  return val
 }

 var otherVehicle T
 fmt.Printf("Not implemented. Returning with default values for \"%v\"\n", id)
 return otherVehicle
}

You can see complete example here.

I have an odd example

This example will return construct of struct

Hope this inspire you

package main

import (
	"fmt"
)

type testA struct {
	a uint
}
type testB struct {
	b string
}

var mp map[string]func(...interface{}) interface{} = map[string]func(...interface{}) interface{}{
	"struct1": func(para ...interface{}) interface{} {
		return &testA{
			a: para[0].(uint),
		}
	},
	"struct2": func(para ...interface{}) interface{} {
		return &testB{
			b: para[0].(string),
		}
	},
}

func NewSpecial(type_check_str string) func(...interface{}) interface{} {
	if val, ok := mp[type_check_str]; ok {
		return val
	}
	return nil
}

func main() {

	test1 := NewSpecial("struct1")(uint(5))
	test2 := NewSpecial("struct2")("It's Ok?")
	fmt.Println(test1)
	fmt.Println(test2)
}