Expresiones contextuales y omitidas

Las expresiones contextuales son expresiones que solo son válidas en determinados contextos, como el uso de nombres de elemento en expresiones de copia y actualización sin tener que calificarlas.

Las expresiones se pueden omitir cuando el compilador puede inferirlos e insertarlos automáticamente, como instrucciones evaluate-and-reassign.

Los intervalos abiertos son otro ejemplo que se aplica a expresiones contextuales y omitidas. Solo son válidos dentro de un contexto determinado y el compilador los traduce en expresiones normales Range durante la compilación mediante la inferencia de límites adecuados.

Un valor de tipo Range genera una secuencia de enteros, especificado por un valor inicial, un valor de paso (opcional) y un valor final. Por ejemplo, la expresión literal Range1..3 genera la secuencia 1,2,3. Del mismo modo, la expresión 3..-1..1 genera la secuencia 3.2.1. También puede usar intervalos para crear una nueva matriz a partir de una existente mediante la segmentación, por ejemplo:

    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]

No se puede definir un intervalo infinito en Q#; Los valores inicial y final siempre deben especificarse. La única excepción es cuando se usa un Range para segmentar una matriz. En ese caso, el compilador puede deducir razonablemente los valores inicial o final del intervalo.

En los ejemplos de segmentación de matriz anteriores, es razonable que el compilador suponga que el extremo del intervalo previsto debe ser el índice del último elemento de la matriz si el tamaño del paso es positivo. Si el tamaño del paso es negativo, es probable que el final del intervalo sea el índice del primer elemento de la matriz, 0. El contrario se mantiene para el inicio del intervalo.

Para resumir, si se omite el valor de inicio del intervalo, el valor inicial inferido

• es cero si no se especifica ningún paso o el paso especificado es positivo.
• es la longitud de la matriz menos una si el paso especificado es negativo.

Si omite el valor final del intervalo, el valor final inferido

• es la longitud de la matriz menos una si no se especifica ningún paso o el paso especificado es positivo.
• es cero si el paso especificado es negativo.

Q# por lo tanto, permite el uso de intervalos abiertos dentro de expresiones de segmentación de matriz, por ejemplo:

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

Dado que la determinación de si el paso de intervalo es positivo o negativo se produce en tiempo de ejecución, el compilador inserta una expresión adecuada que se evalúa en tiempo de ejecución. Para los valores finales omitidos, la expresión insertada es step < 0 ? 0 | Length(arr)-1y para los valores iniciales omitidos se step < 0 ? Length(arr)-1 | 0, donde step es la expresión dada para el paso de intervalo o 1 si no se especifica ningún paso.