Wie können die Generika von Go verwendet werden, um einen flexiblen und typsicheren Typ zu implementieren?

Implementierung generischer Entweder-Typen in Go

Mit der Einführung von Generika in Go 1.18 ist es möglich geworden, generische Datenstrukturen wie den Entweder-Typ zu erstellen, der kann einen von zwei möglichen Werten darstellen. Dies behebt die Einschränkung, sowohl einen Wert als auch einen Fehler zurückzugeben, wie im idiomatischen Go-Ansatz zur Fehlerbehandlung.

Ein Ansatz zur Implementierung eines generischen Entweder-Typs umfasst die Verwendung eines None-Typs und einer optionalen Schnittstelle. None stellt das Fehlen eines Werts dar, während Optional eine Möglichkeit bietet, einen Wert oder einen Fehler abzurufen. Darüber hinaus werden die Typen „Left“ und „Right“ definiert, um die beiden möglichen Werte darzustellen, die „Entweder“ enthalten kann.

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

type None[T any] struct {}
type Some[T any] struct {
    data T
}

Die Schnittstelle „Entweder“ bietet Methoden, um zu bestimmen, ob sie einen linken oder rechten Wert enthält, und Methoden, um auf beide Typen zuzugreifen von Werten mithilfe der Suchmethoden.

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
}

Hilfsfunktionen werden bereitgestellt, um Entweder-Instanzen zu erstellen und auf ihre Werte zuzugreifen.

func left[A, B any](data A) Either[A, B]
func right[A, B any](data B) Either[A, B]

Das folgende Beispiel zeigt dies die Verwendung des Entweder-Typs:

var e1 Either[int, string] = left[int, string](4143)
var e2 Either[int, string] = right[int, string]("G4143")
fmt.Println(e1)
fmt.Println(e2)

Die Ausgabe lautet:

left(4143)
right(G4143)

Durch Zugriff auf die Methoden is_left und is_right ist es möglich, den Typ des von Both gehaltenen Werts zu bestimmen . Mit den Methoden find_left und find_right kann der tatsächliche Wert abgerufen werden.

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

Dieses Beispiel zeigt, wie der Typ „Entweder“ verwendet werden kann, um verschiedene Arten von Werten flexibel und typsicher darzustellen und zu verarbeiten.

Das obige ist der detaillierte Inhalt vonWie können die Generika von Go verwendet werden, um einen flexiblen und typsicheren Typ zu implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!