How to Create New Objects of a Specific Type Using Generics in Go 1.18?

Creating New Objects with Generics in Go 1.18

Generics in Go 1.18 beta offer a powerful way to create flexible and reusable code. One common task is creating new objects of a specific type. However, implementing this functionality requires some understanding of the generics syntax.

Issue: Creating Objects via Generics

The code below defines a FruitFactory with a generic type parameter T. The Create method attempts to create a new instance of T (e.g., *Apple), but it currently returns nil, causing the program to crash when accessing the object's properties.

type FruitFactory[T any] struct{}

func (f FruitFactory[T]) Create() *T {
    // How to create a non-nil fruit here?
    return nil
}

type Apple struct {
    color string
}

func example() {
    appleFactory := FruitFactory[Apple]{}
    apple := appleFactory.Create()
    // Panics because nil pointer access
    apple.color = "red"
}

Solution: Initialize and Return a Variable

Since Apple is a non-pointer type, we can simply declare a variable of type T and return its address:

func (f FruitFactory[T]) Create() *T {
    var a T
    return &a
}

Alternatively, new(T) can be used to create a new instance and return its pointer:

func (f FruitFactory[T]) Create() *T {
    return new(T)
}

With these changes, the Create method now returns a valid object of type T, resolving the nil pointer issue.

Handling Pointer Types

If FruitFactory is instantiated with a pointer type, a more complex solution is required to avoid segmentation faults. A custom interface, Ptr, is needed to constrain pointer types in the type parameter:

// Constraining a type to its pointer type
type Ptr[T any] interface {
    *T
}

// The first type parameter will match pointer types and infer U
type FruitFactory[T Ptr[U], U any] struct{}

func (f FruitFactory[T,U]) Create() T {
    // Declare var of non-pointer type. This is not nil!
    var a U
    // Address it and convert to pointer type (still not nil)
    return T(&a)
}

With this setup, it becomes possible to create new instances of pointer types within the generic factory, preventing segmentation faults.

The above is the detailed content of How to Create New Objects of a Specific Type Using Generics in Go 1.18?. For more information, please follow other related articles on the PHP Chinese website!