Expressions de copie et de mise à jour

Pour réduire le besoin de liaisons mutables, Q# prend en charge les expressions de copie et de mise à jour pour les tableaux, ce qui vous permet d’accéder aux éléments via un index ou une plage d’index.

Les expressions copy-and-update instancient un nouveau tableau avec tous les éléments définis sur la valeur correspondante dans le tableau d’origine, à l’exception des éléments spécifiés, qui sont définis sur ceux définis sur le côté droit de l’expression. Ils sont construits à l’aide d’un opérateur ternaire w/<-; la syntaxe w/ doit être lue comme la notation abrégée couramment utilisée pour « with » :

    original w/ itemAccess <- modification

où original est une expression de tableau, itemAccess est une expression valide pour le découpage de tableau et modification est la nouvelle valeur ou les nouvelles valeurs. Concrètement, l’expression itemAccess peut être de type Int ou Range. Si itemAccess est une valeur de type Int, le type de modification doit correspondre au type d’élément du tableau. Si itemAccess est une valeur de type Range, le type de modification doit être identique au type de tableau.

Par exemple, si arr contient un tableau [0, 1, 2, 3], puis

• arr w/ 0 <- 10 est le tableau [10, 1, 2, 3].
• arr w/ 2 <- 10 est le tableau [0, 1, 10, 3].
• arr w/ 0..2..3 <- [10, 12] est le tableau [10, 1, 12, 3].

En termes de précédence, l’opérateur copy-and-update est associatif de gauche et a la priorité la plus faible, et, en particulier, la priorité inférieure à l’opérateur de plage (..) ou l’opérateur conditionnel ternaire (?|). L’associativité gauche choisie permet un chaînage facile d’expressions de copie et de mise à jour :

    let model = ArrayConstructor()
        w/ 1 <- alpha
        w/ 3 <- gamma
        w/ 5 <- epsilon;

Comme pour tout opérateur qui construit une expression du même type que l’expression la plus à gauche impliquée, l’instruction evaluate-and-reassignation correspondante est disponible. Les deux instructions suivantes, par exemple, obtiennent ce qui suit : la première instruction déclare une variable mutable arr et la lie à la valeur par défaut d’un tableau entier. La deuxième instruction génère ensuite un nouveau tableau avec le premier élément (avec l’index 0) défini sur 10 et le réaffecte à arr.

    mutable arr = [0, size = 3]; // arr contains [0, 0, 0]
    arr w/= 0 <- 10;             // arr contains [10, 0, 0] 

La deuxième instruction est simplement courte pour la syntaxe plus détaillée arr = arr w/ 0 <- 10;.

Les expressions de copie et de mise à jour permettent la création efficace de nouveaux tableaux basés sur des expressions existantes. L’implémentation des expressions de copie et de mise à jour évite de copier l’ensemble du tableau en dupliquant uniquement les parties nécessaires pour obtenir le comportement souhaité et effectuer une modification sur place si possible. Par conséquent, les initialisations de tableau n’entraînent pas de surcharge supplémentaire en raison de l’immuabilité.

L’espace de noms Std.Arrays fournit un arsenal d’outils pratiques pour la création et la manipulation de tableaux.

Les expressions de copie et de mise à jour sont un moyen pratique de construire de nouveaux tableaux à la volée ; l’expression suivante, par exemple, prend la valeur d’un tableau avec tous les éléments définis sur PauliI, à l’exception de l’élément à l’index i, qui est défini sur PauliZ:

[PauliI, size = n] w/ i <- PauliZ