Comment pouvons-nous implémenter un type générique de l'un ou l'autre dans Go pour gérer les valeurs de retour de l'un ou l'autre ?

Implémentation d'un type générique dans Go

Introduction

Avec l'avènement des génériques dans Go 1.18, les développeurs ont réfléchi à la possibilité de créer un générique Soit le type [A, B]. Ce type exprimerait qu'une valeur peut être de type A ou B. Les situations dans lesquelles un tel type serait utile incluent des fonctions qui renvoient l'une des deux valeurs possibles (par exemple, un résultat normal ou une erreur).

Alors que l'approche idiomatique de Go pour la gestion des erreurs consiste à renvoyer à la fois une valeur "normale" et une valeur d'erreur, certains soutiennent que cela est sémantiquement incorrect car cela implique que la fonction renvoie à la fois A et B lorsque l'intention est de renvoyer A ou B.

Le défi

Créer un type Any dans Go présente un défi car son interface doit inclure une méthode qui accepte deux fonctions comme arguments, une pour le type A et une pour le type B. Cependant , Go n'autorise pas les méthodes d'interface à avoir des paramètres de type.

Une solution inspirée de la programmation fonctionnelle

Pour contourner cette restriction, une approche consiste à emprunter la solution à langages de programmation fonctionnels comme OCaml. Dans cette solution, nous définissons un type facultatif qui peut représenter soit une valeur, soit rien (c'est-à-dire Aucun). Nous définissons ensuite un type Soit qui encapsule deux types facultatifs, un pour le type A et un pour le type B.

type Optional[T any] interface {
    get() (T, error)
}

type Either[A, B any] interface {
    is_left() bool
    is_right() bool
    find_left() Optional[A]
    find_right() Optional[B]
}

type Left[A, B any] struct {
    data A
}

type Right[A, B any] struct {
    data B
}

L'interface Soit définit des méthodes pour déterminer si la valeur est une Gauche (type A) ou une Droite (tapez B) et récupérez le type facultatif encapsulé. Les structures Left et Right implémentent ces méthodes pour représenter les différents cas.

Un exemple

Voici un exemple de la façon d'utiliser le type Soit :

import (
    "fmt"
    "os"
)

func main() {
    var e1 Either[int, string] = left[int, string](4143)
    var e2 Either[int, string] = right[int, string]("G4143")
    fmt.Println(e1)
    fmt.Println(e2)
    if e1.is_left() {
        if l, err := e1.find_left().get(); err == nil {
            fmt.Printf("The int is: %d\n", l)
        } else {
            fmt.Fprintln(os.Stderr, err)
        }
    }
    if e2.is_right() {
        if r, err := e2.find_right().get(); err == nil {
            fmt.Printf("The string is: %s\n", r)
        } else {
            fmt.Fprintln(os.Stderr, err)
        }
    }
}

Dans Dans cet exemple, nous créons deux valeurs Soit : e1 qui est une gauche contenant un entier et e2 qui est une droite contenant une chaîne. Nous montrons comment effectuer une correspondance de modèle sur les valeurs de l'un ou l'autre à l'aide des méthodes is_left() et is_right() pour accéder aux valeurs sous-jacentes et les gérer en conséquence.

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!