Comment puis-je créer une fonction Go générique qui accepte un pointeur vers une implémentation d'interface ?

Implémentation d'un pointeur générique vers une interface

Dans Go, définir une fonction générique qui accepte un pointeur vers une interface peut être difficile. Considérons une interface A avec un SomeMethod() :

type A interface {
  SomeMethod()
}

Et supposons qu'il existe une implémentation de A en tant que pointeur de structure :

type Aimpl struct {}

func (a *Aimpl) SomeMethod() {}

Pour créer un gestionnaire de fonction générique qui prend une fonction avec un paramètre A, il serait souhaitable de définir :

func Handler[T A](callback func(result T)) {
  // Essentially what I'd like to do is result := &Aimpl{} (or whatever T is)
  callback(result)
}

Il existe cependant quelques contraintes à considérer.

Tentative avec n'importe quel paramètre de type

Au départ, il peut sembler possible de définir une interface avec un paramètre de type pour permettre les implémentations de pointeurs :

type MyA[T any] interface{
  A
  *T
}

Cependant, cela échoue avec l'erreur suivante :

result does not implement interface. It's a pointer to a type, not a type

Solution : Type Interface paramétrée

Pour surmonter cela, l'interface peut être déclarée avec un paramètre de type qui nécessite que le type d'implémentation soit un pointeur vers son paramètre de type :

type A[P any] interface {
    SomeMethod()
    *P
}

Avec cette interface , la fonction Handler peut être modifiée :

func Handler[P any, T A[P]](callback func(result T)) {
    result := new(P)
    callback(result)
}

Maintenant, le code peut appeler Handler comme attendu :

Handler(func(a *Aimpl) { fmt.Printf("%#v\n", a) })

Alternative avec Interface Wrapper

Si la définition de A ne peut pas être modifiée, une approche alternative consiste à l'envelopper dans une interface personnalisée :

type MyA[P any] interface {
    A
    *P
}

Et modifiez la fonction Handler en conséquence :

func Handler[P any, T MyA[P]](callback func(result T)) {
    result := new(P)
    callback(result)
}

Les deux solutions permettent de créer des fonctions génériques qui acceptez les pointeurs vers les implémentations d’interface.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!