Expressions contextuelles et omises

Les expressions contextuelles sont des expressions valides uniquement dans certains contextes, tels que l’utilisation de noms d’éléments dans les expressions de copie et de mise à jour sans avoir à les qualifier.

Les expressions peuvent être omises quand elles peuvent être déduites et insérées automatiquement par le compilateur, par exemple, dans le cas d’instructions d’évaluation et de réattribution.

Les plages illimitées sont un autre exemple qui s’applique aux expressions contextuelles et omises. Ils sont valides uniquement dans un certain contexte, et le compilateur les traduit en expressions normales Range pendant la compilation en inférence des limites appropriées.

Une valeur de type Range génère une séquence d’entiers, spécifiée par une valeur de début, une valeur de pas (facultative) et une valeur de fin. Par exemple, l’expression littérale Range 1..3 génère la séquence 1, 2, 3. De même, l’expression 3..-1..1 génère la séquence 3,2,1. Vous pouvez également utiliser des plages pour créer un nouveau tableau à partir d’un tableau existant par découpage, par exemple :

    let arr = [1,2,3,4];
    let slice1 = arr[1..2..4];  // contains [2,4] 
    let slice2 = arr[2..-1..0]; // contains [3,2,1]

Vous ne pouvez pas définir une plage infinie en Q# ; les valeurs de début et de fin doivent toujours être spécifiées. La seule exception est lorsque vous utilisez un élément Range pour segmenter un tableau. Dans ce cas, les valeurs de début et de fin de la plage peuvent raisonnablement être déduites par le compilateur.

Dans les exemples précédents de découpage de tableau, le compilateur peut raisonnablement supposer que la fin de plage prévue doit être l’index du dernier élément du tableau, si la taille de pas est positive. Si la taille de pas est négative, la fin de la plage doit être l’index du premier élément du tableau, 0. L’inverse vaut pour le début de la plage.

Pour résumer, si vous omettez la valeur de début de plage, la valeur de début déduite

• est égale à zéro si aucun pas n’est spécifié ou si le pas spécifié est positif.
• est égale à la longueur du tableau moins un, si l’étape spécifiée est négative.

Si vous omettez la valeur de fin de plage, la valeur de fin déduite

• est égale à la longueur du tableau moins un, si aucun pas n’est spécifié ou si le pas spécifié est positif.
• est égale à zéro si l’étape spécifiée est négative.

Q# autorise donc l’utilisation de plages illimitées dans les expressions de découpage de tableau, par exemple :

let arr = [1,2,3,4,5,6];
let slice1  = arr[3...];      // slice1 is [4,5,6];
let slice2  = arr[0..2...];   // slice2 is [1,3,5];
let slice3  = arr[...2];      // slice3 is [1,2,3];
let slice4  = arr[...2..3];   // slice4 is [1,3];
let slice5  = arr[...2...];   // slice5 is [1,3,5];
let slice7  = arr[4..-2...];  // slice7 is [5,3,1];
let slice8  = arr[...-1..3];  // slice8 is [6,5,4];
let slice9  = arr[...-1...];  // slice9 is [6,5,4,3,2,1];
let slice10 = arr[...];       // slice10 is [1,2,3,4,5,6];

Comme la détermination de la positivité ou de la négativité du pas de plage se déroule au moment de l’exécution, le compilateur insère une expression appropriée qui est évaluée au moment de l’exécution. Pour les valeurs de fin omises, l’expression insérée est step < 0 ? 0 | Length(arr)-1 et step < 0 ? Length(arr)-1 | 0 pour les valeurs de début omises, où step est l’expression donnée pour l’étape de plage, ou 1 si aucune étape n’est spécifiée.