Génériques en Zero : paramètres de type sur fonctions et shapes

Pourquoi les génériques

Vous tombez vite sur des types qui devraient fonctionner pour plus d'un type d'élément. Une « paire » de deux valeurs ne se soucie pas que les valeurs soient des entiers, des chaînes, ou un shape défini par l'utilisateur. Les génériques vous permettent d'écrire le type une seule fois et de l'instancier avec les types d'élément dont l'appelant a besoin.

L'alternative — écrire IntPair, StringPair, BytePair, etc. — devient vite lassante et ne se compose pas. Les génériques en Zero sont l'outil standard pour ça.

Fonctions génériques

Déclarez les paramètres de type entre chevrons, entre le nom de la fonction et la liste des paramètres :

fun makePair<T, U>(left: T, right: U) -> Pair<T, U> {
    return Pair { left: left, right: right }
}

T et U sont des types placeholders — l'appelant décide ce qu'ils sont.

Les appels n'ont généralement pas besoin de les épeler ; le compilateur infère depuis les types des arguments :

let pair = makePair(40, 2_u8)

Ici, T est inféré à i32 (le défaut pour un littéral entier sans suffixe) et U à u8 (depuis le suffixe _u8). La liaison résultante pair est de type Pair<i32, u8>.

Si l'inférence choisirait les mauvais types — par exemple parce que les littéraux sont ambigus — vous pouvez fixer les paramètres sur le site d'appel :

let pair = makePair<u8, u8>(1, 2)

(La syntaxe d'appel à chevrons exacte peut varier selon les versions de Zero ; vérifiez la doc actuelle pour l'orthographe précise. Le comportement d'inférence par défaut est la partie stable.)

Shapes génériques

Les shapes prennent des paramètres de type de la même façon :

shape Pair<T, U> {
    left: T,
    right: U,
}

Le type de chaque champ peut mentionner les paramètres. Les instances les fixent :

let intBytes: Pair<i32, u8> = Pair { left: 40, right: 2_u8 }
let words:    Pair<String, String> = Pair { left: "hi", right: "there" }

Un exemple complet combinant un shape générique et une fonction générique — cliquez sur Run pour voir l'inférence à l'œuvre :

shape Pair<T, U> {
    left: T,
    right: U,
}

fun makePair<T, U>(left: T, right: U) -> Pair<T, U> {
    return Pair { left: left, right: right }
}

pub fun main(world: World) -> Void raises {
    let pair: Pair<i32, u8> = makePair(40, 2_u8)
    if pair.left == 40 && pair.right == 2_u8 {
        check world.out.write("generic pair ok\n")
    } else {
        check world.out.write("generic pair broke\n")
    }
}

Une déclaration de shape générique, une fonction générique, un site d'appel fortement typé. Pas de boilerplate IntBytePair.

Alias de type

Quand le même type paramétré revient encore et encore, donnez-lui un nom avec type :

type BytePair = Pair<u8, u8>

Maintenant BytePair est interchangeable avec Pair<u8, u8> partout où vous pouvez écrire un type :

type BytePair = Pair<u8, u8>

shape Pair<T, U> {
    left: T,
    right: U,
}

pub fun main(world: World) -> Void raises {
    let pair: BytePair = Pair { left: 1_u8, right: 2_u8 }
    if pair.left == 1_u8 && pair.right == 2_u8 {
        check world.out.write("type alias ok\n")
    } else {
        check world.out.write("type alias broke\n")
    }
}

Un alias n'est qu'une fonctionnalité de nommage — il ne crée pas un type distinct. Une fonction qui prend un BytePair acceptera volontiers une valeur de type Pair<u8, u8> (et inversement).

Génériques dans la bibliothèque standard

Le même mécanisme alimente une grande partie de la bibliothèque standard. Quelques-uns que vous verrez dans du vrai code Zero :

• Maybe<T> — une valeur optionnelle, contenant soit un T, soit rien.
• Span<T> — une tranche empruntée sur des valeurs T. Span<u8> est la vue canonique sur un tampon d'octets.
• ref<T> et mutref<T> — des types de référence explicites pour les cas où vous devez partager des données sans copier.

Vous n'avez pas à tous les apprendre d'un coup. L'intérêt des génériques, c'est que le même shape fonctionne pour le type d'élément que vous avez sous la main.

Quand les génériques paient (et quand ils ne paient pas)

Recourez aux génériques quand vous vous retrouvez à écrire la même fonction ou le même shape deux fois avec des types d'élément différents. Recourez à un type concret quand :

• La logique de la fonction n'a de sens que pour un type précis (un parseur pour des String, par exemple).
• Vous voulez que le type apparaisse dans les messages d'erreur pour faciliter le débogage.
• Les caractéristiques de performance dépendent d'une taille mémoire précise.

Le coût des génériques est réel — binaires plus gros (chaque instanciation génère un nouveau code) et temps de compilation un peu plus longs. Pour la plupart du code applicatif, ce coût est négligeable, mais c'est bon à savoir quand vous construisez du code compact et embarqué où la taille du binaire compte.

Une note sur les contraintes

Certains systèmes génériques permettent de contraindre un paramètre de type (« T doit supporter == », « T doit implémenter Iterator »). L'histoire des contraintes en Zero pré-1.0 évolue encore — les exemples dans le dépôt officiel utilisent les génériques sous leur forme simple, sans bornes élaborées. À mesure que le langage se stabilisera, attendez-vous à ce qu'une syntaxe de contraintes apparaisse sous une forme petite et régulière, cohérente avec le reste du langage. Pour l'instant, écrivez des génériques qui fonctionnent pour tout T que vous leur passez réellement, et laissez le compilateur vous dire quand une opération n'est pas supportée.

La suite : les enums

Les génériques vous permettent de paramétrer sur des types. La prochaine brique est à l'autre bout du spectre — les enums, le type d'énumération simple de Zero pour les cas où les variantes ne portent pas de données supplémentaires.