Priorité et associativité

Priorité et associativité définissent l’ordre dans lequel les opérateurs sont appliqués. Les opérateurs dotés d’une priorité plus élevée sont d’abord liés à leurs arguments (opérandes), tandis que les opérateurs dotés de la même priorité se lient dans la direction de leur associativité. Par exemple, l’expression 1+2*3 en fonction de la priorité pour l’addition et la multiplication est équivalente à 1+(2*3), et 2^3^4 à 2^(3^4) puisque l’élévation à une puissance est associative à droite.

Opérateurs

Le tableau suivant répertorie les opérateurs disponibles dans Q#, ainsi que leur priorité et leur associativité. Des modificateurs et combinateurs supplémentaires sont également répertoriés et se lient plus étroitement que tous ces opérateurs.

Les expressions copy-and-update doivent nécessairement avoir la priorité la plus faible pour garantir un comportement cohérent de l'instruction evaluate-and-reassigncorrespondante. Des considérations similaires s’appliquent à l’opérateur range pour garantir un comportement cohérent de l'expression contextuellecorrespondante.

Modificateurs et combinateurs

Les modificateurs peuvent être considérés comme des opérateurs spéciaux susceptibles d’être appliqués à certaines expressions uniquement. Il est possible de leur attribuer une priorité artificielle pour capturer leur comportement.

Pour plus d’informations, consultez Expressions.

Cette priorité artificielle est indiquée dans le tableau suivant, qui montre également comment la précédence des opérateurs et des modificateurs est liée à la façon dont les combinateurs d’accès aux éléments ([, ] et :: respectivement) et les combinateurs d’appel ((, )) se lient.

Pour illustrer les implications des précédences attribuées, supposons que nous ayons une opération unitaire DoNothing (telle que définie dans Déclarations de spécialisation), un callable GetStatePrep qui retourne une opération unitaire, et un tableau algorithms contenant des éléments de type Algorithm définis comme suit

    newtype Algorithm = (
        Register : Qubit[],
        Initialize : Transformation,
        Apply : Transformation
    );

    newtype Transformation =
        Qubit[] => Unit is Adj + Ctl;

Les expressions suivantes sont alors toutes valides :

    GetStatePrep()(arg)
    (Transformation(GetStatePrep()))!(arg)
    Adjoint DoNothing()
    Controlled Adjoint DoNothing(cs, ())
    Controlled algorithms[0]::Apply!(cs, _)
    algorithms[0]::Register![i]

En examinant les précédences définies dans le tableau ci-dessus, vous pouvez constater que les parenthèses entourant (Transformation(GetStatePrep())) sont nécessaires pour appliquer l’opérateur de désencapsulage à la valeur Transformation plutôt qu’à l’opération retournée. Cela étant, les parenthèses ne sont pas requises dans GetStatePrep()(arg). Les fonctions sont appliquées de gauche à droite et dès lors, cette expression est équivalente à (GetStatePrep())(arg). Les applications de foncteur n’ont pas non plus besoin de parenthèses pour appeler la spécialisation correspondante et il en va de même pour les expressions d’accès aux tableau et aux éléments nommés. Ainsi, l’expression arr2D[i][j] est parfaitement valide, tout comme algorithms[0]::Register![i].