Expressões contextuais e omitidas

Expressões contextuais são expressões que só são válidas em determinados contextos, como o uso de nomes de itens em expressões copiar e atualizar sem ter que qualificá-las.

As expressões podem ser omitidas quando podem ser inferidas e inseridas automaticamente pelo compilador, como instruções de avaliação e reatribuição.

Os intervalos abertos são outro exemplo que se aplica a expressões contextuais e omitidas. Eles são válidos apenas dentro de um determinado contexto, e o compilador os traduz em expressões Range normais durante a compilação, inferindo limites adequados.

Um valor do tipo Range gera uma sequência de inteiros, especificada por um valor inicial, um valor de etapa (opcional) e um valor final. Por exemplo, a expressão literal Range1..3 gera a sequência 1,2,3. Da mesma forma, a expressão 3..-1..1 gera a sequência 3,2,1. Você também pode usar intervalos para criar uma nova matriz a partir de uma existente fatiando, por exemplo:

    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]

Você não pode definir um intervalo infinito em Q#; Os valores de início e fim sempre precisam ser especificados. A única exceção é quando você usa um Range para fatiar uma matriz. Nesse caso, o compilador pode razoavelmente inferir os valores de início ou fim do intervalo.

Nos exemplos de fatiamento de matriz anteriores, é razoável para o compilador assumir que o final do intervalo pretendido deve ser o índice do último item na matriz se o tamanho da etapa for positivo. Se o tamanho da etapa for negativo, então o final do intervalo provavelmente deve ser o índice do primeiro item na matriz, 0. O inverso vale para o início do intervalo.

Para resumir, se você omitir o valor inicial do intervalo, o valor inicial inferido

• é zero se nenhuma etapa for especificada ou se a etapa especificada for positiva.
• é o comprimento da matriz menos um se a etapa especificada for negativa.

Se você omitir o valor final do intervalo, o valor final inferido

• é o comprimento da matriz menos um se nenhuma etapa for especificada ou se a etapa especificada for positiva.
• é zero se a etapa especificada for negativa.

Q#, portanto, permite o uso de intervalos abertos dentro de expressões de fatiamento de matriz, por exemplo:

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];

Como a determinação se a etapa do intervalo é positiva ou negativa acontece no tempo de execução, o compilador insere uma expressão adequada que é avaliada no tempo de execução. Para valores finais omitidos, a expressão inserida é step < 0 ? 0 | Length(arr)-1, e para valores iniciais omitidos é step < 0 ? Length(arr)-1 | 0, onde step é a expressão dada para a etapa do intervalo, ou 1 se nenhuma etapa for especificada.