Literais

Unidade literal

O único literal existente para o tipo Unit é o valor ().

O valor Unit é comumente usado como um argumento para chamáveis, seja porque nenhum outro argumento precisa ser passado ou para atrasar a execução. Ele também é usado como valor de retorno quando nenhum outro valor precisa ser retornado, o que é o caso de operações unitárias, ou seja, operações que suportam o Adjoint e/ou o functor Controlled.

Literais Int

Os literais de valor para o tipo Int podem ser expressos em representação binária, octal, decimal ou hexadecimal. Literais expressos em binário são prefixados com 0b, com 0o para octal e com 0x para hexadecimal. Não há prefixo para a representação decimal comumente usada.

Literais BigInt

Os literais de valor para o tipo BigInt são sempre pós-fixados com L e podem ser expressos em representação binária, octal, decimal ou hexadecimal. Literais expressos em binário são prefixados com 0b, com 0o para octal e com 0x para hexadecimal. Não há prefixo para a representação decimal comumente usada.

Literais duplos

Os literais de valor para o tipo Double podem ser expressos em notação padrão ou científica.

Se nada se seguir após a vírgula decimal, então o dígito após a vírgula decimal pode ser omitido. Por exemplo, 1. é um Double literal válido e o mesmo que 1.0.

Bool literais

Os literais existentes para o tipo Bool são true e false.

Literais de cadeia de caracteres

Um valor literal para o tipo String é uma sequência de comprimento arbitrário de caracteres Unicode entre aspas duplas. Dentro de uma cadeia de caracteres, o \ de caracteres de barra invertida pode ser usado para escapar de um caractere de aspas duplas e para inserir uma nova linha como \n, um retorno de carro como \re uma guia como \t.

A seguir estão exemplos de literais de cadeia de caracteres válidos:

"This is a simple string."
"\"This is a more complex string.\", she said.\n"

Q# também suporta strings interpoladas. Uma cadeia de caracteres interpolada é um literal de cadeia de caracteres que pode conter qualquer número de expressões de interpolação. Estas expressões podem ser de tipos arbitrários. Após a construção, as expressões são avaliadas e sua representação String é inserida no local correspondente dentro do literal definido. A interpolação é ativada ao antecipar o caractere especial $ diretamente antes da citação inicial, sem espaço em branco entre eles.

Por exemplo, se res é uma expressão que é avaliada como 1, então a segunda frase no seguinte String literal exibe "O resultado foi 1.":

$"This is an interpolated string. The result was {res}."

Literais Qubit

Não existem literais para o tipo Qubit, uma vez que a memória quântica é gerenciada pelo tempo de execução. Por conseguinte, os valores do tipo Qubit só podem ser obtidos através de de atribuição.

Valores do tipo Qubit representam um identificador opaco pelo qual um bit quântico, ou qubit, pode ser endereçado. O único operador que eles apoiam é comparação de igualdade. Para obter mais informações sobre o tipo de dados Qubit, consulte Qubits.

Literais de resultado

Os literais existentes para o tipo Result são Zero e One.

Os valores do tipo Result representam o resultado de uma medição quântica binária. Zero indica uma projeção no espaço próprio +1 One indica uma projeção no autoespaço -1.

Literais de Pauli

Os literais existentes para o tipo Pauli são PauliI, PauliX, PauliYe PauliZ.

Os valores do tipo Pauli representam uma das quatro matrizes de Pauli de qubit único, com PauliI representando a identidade. Os valores do tipo Pauli são normalmente utilizados para indicar o eixo das rotações e para especificar em relação a que base medir.

Literais de intervalo

Literais de valor para o tipo Range são expressões da forma start..step..stop, onde start, stepe end são expressões do tipo Int. Se o tamanho do passo for um, ele pode ser omitido. Por exemplo, start..stop é um Range literal válido e o mesmo que start..1..stop.

Os valores do tipo Range representam uma sequência de inteiros, onde o primeiro elemento da sequência é start, e os elementos subsequentes são obtidos adicionando step ao anterior, até que stop seja passado. Range valores são inclusivos em ambas as extremidades, ou seja, o último elemento do intervalo é stop se a diferença entre start e stop for um múltiplo de step. Um intervalo pode estar vazio se, por exemplo, step for positivo e stop < start.

Seguem-se exemplos de literais Range válidos:

• 1..3 é o intervalo 1, 2, 3.
• 2..2..5 é o intervalo 2, 4.
• 2..2..6 é o intervalo 2, 4, 6.
• 6..-2..2 é o intervalo 6, 4, 2.
• 2..-2..1 é o intervalo 2.
• 2..1 é o intervalo vazio.

Para obter mais informações, consulte Expressões contextuais.

Literais de matriz

Uma matriz literal é uma sequência de zero ou mais expressões, separadas por vírgulas e entre parênteses [ e ]; por exemplo, [1,2,3]. Todas as expressões devem ter um tipo de base comum, que é o tipo de item da matriz. Se uma matriz vazia for especificada com [], uma anotação de tipo pode ser necessária para que o compilador determine o tipo apropriado da expressão.

Matrizes de comprimento arbitrário podem ser criadas usando uma expressão de matriz de tamanho. Tal expressão é da forma [expr, size = s], onde s pode ser qualquer expressão do tipo Int e expr é avaliada para um valor que serão os itens da matriz repetidos s vezes. Por exemplo, [1.2, size = 3] cria a mesma matriz que [1.2, 1.2, 1.2].

Literais de tupla

Uma tupla literal é uma sequência de uma ou mais expressões de qualquer tipo, separadas por vírgulas e entre parênteses ( e ). O tipo de tupla inclui as informações sobre cada tipo de item.

As tuplas que contêm um único item são tratadas como idênticas ao próprio item, tanto em tipo quanto em valor, o que é chamado equivalência de tupla de tonelada única.

As tuplas são usadas para agrupar valores em um único valor, facilitando a sua transmissão. Isso torna possível para cada chamável ter exatamente uma entrada e retornar exatamente uma saída.

Literais para tipos struct

Os valores de um tipo struct são atribuídos quando você cria uma nova instância, usando a instrução new ou o construtor criado pelo compilador.

Por exemplo, se IntPair for um struct definido como

struct IntPair {
    num1 : Int,
    num2 : Int,    
}

Em seguida, você cria uma nova instância e atribui valores usando

let MyPair = new IntPair { num1 = 5, num2 = 7 };

ou

let MyPair = IntPair(5, 7);

Literais de operação e função

Operações e funções anônimas podem ser criadas usando uma expressão lambda .