Assurer une comparabilité stricte au moment de la compilation dans Go 1.20 ?

L'éditeur php Baicao vous présente une fonctionnalité importante de la version 1.20 du langage Go : une comparabilité stricte au moment de la compilation. Dans la version 1.20 du langage Go, de nouveaux indicateurs du compilateur sont introduits pour garantir que les fichiers binaires générés lors de la compilation sont comparables dans différents environnements de compilation. Cela signifie que les binaires générés dans différents environnements de compilation auront le même comportement et les mêmes résultats, réduisant ainsi les problèmes potentiels causés par différents environnements de compilation. L'introduction de cette fonctionnalité améliorera encore la fiabilité et la stabilité du langage Go et offrira aux développeurs une meilleure expérience de développement.

Contenu de la question

Dans Go 1.18 et Go 1.19, je peux m'assurer au moment de la compilation qu'un type est strictement comparable, c'est-à-dire qu'il prend en charge == 和 != les opérateurs, et qu'il est garanti de ne pas paniquer lors de l'exécution de ces opérateurs .

Cela est utile, par exemple, pour éviter d'ajouter accidentellement des champs à une structure, provoquant ainsi une panique inutile.

Je viens d'essayer de l'instancier avec

 :comparable

// supports == and != but comparison could panic at run time
type Foo struct {
    SomeField any
}

func ensureComparable[T comparable]() {
    // no-op
}

var _ = ensureComparable[Foo] // doesn't compile because Foo comparison may panic

Cela est possible dans Go 1.18 et 1.19 grâce à la définition de

contraintes : comparable

The predeclared interface type comparable denotes the set of all non-interface types that are comparable

Bien que les spécifications Go 1.18 et 1.19 ne mentionnent pas les types qui ne sont pas des interfaces mais ne peuvent pas être strictement comparés, comme [2]fmt.Stringer ou struct { foo any } , gc compilation Le compilateur les rejette comme arguments de

. [2]fmt.Stringer 或 struct { foo any }，gc 编译器确实拒绝将这些作为 comparable

Un terrain de jeu avec plusieurs exemples : https://go.dev/play/p/_Ggfdnn6OzZ

Dans Go 1.20, l'instanciation

sera cohérente avec le concept plus large de comparabilité. Cela permet à ensureComparable[Foo] de compiler comparable 将与更广泛的可比性概念保持一致。这使得 ensureComparable[Foo] même si je ne le veux pas .

Existe-t-il un moyen d'assurer statiquement une comparabilité stricte avec Go 1.20 ?

Solution de contournement

Pour tester si Foo est strictement comparable dans Go 1.20, instanciez ensureComparable</code en utilisant un <p>paramètre de type<code>Foo 在 Go 1.20 中是否严格可比，请使用受 Foo 约束的类型参数实例化 ensureComparable contraint par Foo >.

// unchanged
type Foo struct {
    SomeField any
}

// unchanged
func ensureComparable[T comparable]() {}

// T constrained by Foo, instantiate ensureComparable with T
func ensureStrictlyComparable[T Foo]() {
    _ = ensureComparable[T] // <---- doesn't compile
}

_{Cette solution a été initialement suggérée par Robert Griesemer ici a>.}

Alors comment ça marche ?

Go 1.20 introduit implémenteinterfaces et satisfait contraintes :

Le deuxième point est d'autoriser des exceptions pour l'instanciation des interfaces et des types avec des interfaces comparable .

Maintenant dans Go 1.20, le type Foo lui-même peut être instancié Foo 本身可以实例化 comparable 。但类型参数 T 不是 Foo en raison d'exceptions de satisfiabilité. Mais le paramètre de type T n'est pas Foo. Les définitions de compatibilité pour les paramètres de type diffèrent  :

L'ensemble de types de

T contient un type Foo qui n'est pas strictement comparable (car il a un champ d'interface), donc T ne satisfait pas T 的类型集包含一个不严格可比的类型 Foo （因为它有一个接口字段），因此 T 不满足 comparable。即使 Foo. Cela est vrai même pour Foo lui-même.

Cette astuce empêche effectivement la compilation du programme si l'opérateur de Foo Foo 的运算符 == 和 != risque de paniquer au moment de l'exécution.

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!