Acesso ao item

Q# dá suporte ao acesso de item para itens de matriz e para itens em tipos definidos pelo usuário. Nos dois casos, o acesso é somente leitura, ou seja, o valor não pode ser alterado sem criar uma instância usando uma expressão de cópia e atualização.

Acesso a itens de matriz e divisão de matriz

Dada uma expressão de matriz e uma expressão do tipo Int ou Range, uma nova expressão pode ser formada usando o operador de acesso de item da matriz que consiste em [ e ].

Se a expressão entre colchetes for do tipo Int, a nova expressão conterá o item de matriz nesse índice. Por exemplo, se arr for do tipo Double[] e contiver cinco ou mais itens, arr[4] será uma expressão do tipo Double.

Se a expressão entre colchetes for do tipo Range, a nova expressão conterá uma matriz de todos os itens indexados pelo Range especificado. Se Range estiver vazio, a matriz resultante estará vazia. Por exemplo,

let arr = [10, 11, 36, 49];
let ten = arr[0]; // contains the value 10
let odds = arr[1..2..4]; // contains the value [11, 49]
let reverse = arr[...-1...]; // contains the value [49, 36, 11, 10]

Na última linha do exemplo, os valores inicial e final do intervalo foram omitidos para simplificação. Para obter mais informações, veja Expressões contextuais.

Se a expressão de matriz não for um identificador simples, ela precisará estar entre parênteses para extrair um item ou uma fatia. Por exemplo, se arr1 e arr2 forem matrizes de inteiros, um item da concatenação seria expresso como (arr1 + arr2)[13]. Para obter informações, confira Precedência e associatividade.

Todas as matrizes em Q# são baseadas em zero, ou seja, o primeiro elemento de uma matriz arr é sempre arr[0]. Uma exceção será gerada em tempo de execução se o índice ou um dos índices usados para a divisão estiver fora dos limites da matriz, ou seja, for inferior a zero ou superior ou igual ao comprimento da matriz.

Acesso ao item para tipos definidos pelo usuário

(Para obter mais informações de como definir tipos personalizados que contêm um ou mais itens nomeados ou anônimos, confira Declarações de tipo).

Os itens contidos podem ser acessados por meio de seu nome ou por desconstrução, ilustrados pelas seguintes instruções que podem ser usadas como parte de uma operação ou implementação de função:

    let complex = Complex(1., 0.); // create a value of type Complex
    let (re, _) = complex!;       // item access via deconstruction
    let im = complex::Imaginary;  // item access via name

O operador de acesso ao item (::) recupera itens nomeados, conforme ilustrado pelo exemplo a seguir:

newtype TwoStrings = (str1 : String, str2 : String);

operation LinkTwoStrings(str : TwoStrings) : String {
    let s1 = str::str1;
    let s2 = str::str2;
    return s1 + s2;
}

Embora itens nomeados possam ser acessados pelo nome ou por desconstrução, itens anônimos só podem ser acessados pela última opção. Como a desconstrução depende de todos os itens contidos, o uso de itens anônimos é desencorajado quando esses itens precisam ser acessados fora da unidade de compilação na qual o tipo é definido.

O acesso por desconstrução usa o operador unwrap (!). Esse operador unwrap retorna uma tupla de todos os itens contidos, em que a forma da tupla corresponde à definida na declaração e uma só tupla de item é equivalente ao item em si (confira esta seção).

Por exemplo, para um valor nested do tipo Nested com a definição a seguir

newtype Nested = (Double, (ItemName : Int, String));

a expressão nested! retorna um valor do tipo (Double, (Int, String)).

O operador ! tem menor precedência do que ambos os operadores de acesso ao item, mas maior precedência do que qualquer outro operador. Para obter uma lista completa de precedências, confira Precedência e associatividade.