Wie können wir einen generischen Entweder-Typ in Go implementieren, um Entweder/Oder-Rückgabewerte zu verarbeiten?

Implementieren eines generischen Entweder-Typs in Go

Einführung

Mit dem Aufkommen von Generika in Go 1.18 haben Entwickler über die Möglichkeit nachgedacht, ein Generikum zu erstellen Entweder der Typ [A, B]. Dieser Typ würde ausdrücken, dass ein Wert entweder vom Typ A oder B sein kann. Situationen, in denen ein solcher Typ nützlich wäre, umfassen Funktionen, die einen von zwei möglichen Werten zurückgeben (z. B. ein normales Ergebnis oder einen Fehler).

Während der idiomatische Ansatz in Go zur Fehlerbehandlung darin besteht, sowohl einen „normalen“ Wert als auch einen Fehlerwert zurückzugeben, argumentieren einige, dass dies semantisch falsch ist, da es impliziert, dass die Funktion sowohl A als auch B zurückgibt, obwohl die Absicht darin besteht, entweder A oder zurückzugeben B.

Die Herausforderung

Das Erstellen eines Both-Typs in Go stellt eine Herausforderung dar, da seine Schnittstelle eine Methode enthalten muss, die zwei Funktionen als Argumente akzeptiert, eine für Typ A und eine für Typ B. Allerdings , Go erlaubt keine Schnittstellenmethoden, Typparameter zu haben.

Eine von der funktionalen Programmierung inspirierte Lösung

Um diese Einschränkung zu umgehen, besteht ein Ansatz darin, die auszuleihen Lösung aus funktionalen Programmiersprachen wie OCaml. In dieser Lösung definieren wir einen optionalen Typ, der entweder einen Wert oder nichts (d. h. None) darstellen kann. Anschließend definieren wir einen Entweder-Typ, der zwei optionale Typen umschließt, einen für Typ A und einen für Typ 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
}

Die Entweder-Schnittstelle definiert Methoden, um zu bestimmen, ob der Wert ein Left (Typ A) oder ein ist Rechts (Typ B) und den umschlossenen optionalen Typ abrufen. Die Left- und Right-Strukturen implementieren diese Methoden, um die verschiedenen Fälle darzustellen.

Ein Beispiel

Hier ist ein Beispiel für die Verwendung des Entweder-Typs:

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)
        }
    }
}

In In diesem Beispiel erstellen wir zwei Entweder-Werte: e1, ein Left, der eine Ganzzahl enthält, und e2, ein Right, der eine Zeichenfolge enthält. Wir zeigen, wie ein Mustervergleich für die Werte „Entweder“ mithilfe der Methoden is_left() und is_right() durchgeführt wird, um auf die zugrunde liegenden Werte zuzugreifen und sie entsprechend zu behandeln.

Das obige ist der detaillierte Inhalt vonWie können wir einen generischen Entweder-Typ in Go implementieren, um Entweder/Oder-Rückgabewerte zu verarbeiten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!