Literais

Literal Unit

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

O valor Unit normalmente é usado como um argumento para chamáveis, por exemplo, porque nenhum outro argumento precisa ser passado ou para atrasar a execução. Ele também é usado como valor retornado quando nenhum outro valor precisa ser retornado, que é o caso das operações unitárias, ou seja, operações compatíveis com o functor Adjoint e/ou 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á nenhum prefixo para a representação decimal comumente usada.

Representação	Literal de valor
Binário	0b101010
Octal	0o52
Decimal	42
Hexadecimal	0x2a

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á nenhum prefixo para a representação decimal comumente usada.

Representação	Literal de valor
Binário	0b101010L
Octal	0o52L
Decimal	42L
Hexadecimal	0x2aL

Literais Double

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

Representação	Literal de valor
Standard	0.1973269804
Científico	1.973269804e-1

Se não houver nada após o ponto decimal, o dígito após o ponto decimal poderá ser omitido. Por exemplo, 1. é um literal Double válido e é o mesmo que 1.0.

Literais boolianos

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 string, o caractere de barra invertida \ pode ser usado para escapar de um caractere de aspas duplas e inserir uma nova linha como \n, um retorno de carro como \r e uma tabulação como \t.

Veja a seguir exemplos para literais de cadeia de caracteres válidos:

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

Q# também aceita cadeias de caracteres interpoladas. Uma cadeia de caracteres interpolada é um literal de cadeia de caracteres que pode conter expressões de interpolação. Essas expressões podem ser de tipos arbitrários. Após a construção, as expressões são avaliadas e a representação String é inserida no local correspondente dentro do literal definido. A interpolação é habilitada ao anexar o caractere especial $ diretamente antes das aspas iniciais, ou seja, sem nenhum espaço em branco entre eles.

Por exemplo, se res for uma expressão avaliada como 1, a segunda frase no seguinte literal String será "O resultado foi 1.":

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

Literais de qubit

Não existem literais para o tipo Qubit, pois a memória quântica é gerenciada pelo runtime. Portanto, os valores do Qubit tipo só podem ser obtidos por meio da alocação.

Os valores do tipo Qubit representam um identificador opaco pelo qual um bit quântico, ou qubit, pode ser chamado. O único operador que aceito é a comparação de igualdade. Para obter mais informações sobre o tipo de dados Qubit, confira Qubits.

Literais de resultado

Literais existentes para o tipo Result são Zero e One.

Os valores do tipo Result representam o resultado de uma medida quântica binária. Zero indica uma projeção no eigenspace +1, One indica uma projeção no eigenspace -1.

Literais de Pauli

Literais existentes para o tipo Pauli são PauliI, PauliX, PauliY e PauliZ.

Os valores do tipo Pauli representam uma das quatro matrizes De Pauli de qubit único, com a representação da identidade PauliI. Valores do tipo Pauli normalmente são usados para denotar o eixo para rotações e especificar com relação a qual base medir.

Literais de intervalo

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

Os valores do tipo Range representam uma sequência de inteiros, startem que o primeiro elemento na sequência é e step os elementos subsequentes são obtidos adicionando ao anterior, stop até que seja passado. Os valores de Range são inclusivos nas duas extremidades. Ou seja, o último elemento do intervalo será 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.

Veja a seguir exemplos para literais de cadeia de Range válido:

• 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, veja Expressões contextuais.

Literais de matriz

Um literal de matriz é uma sequência de zero ou mais expressões, separadas por vírgulas e entre colchetes [ e ]; por exemplo, [1,2,3]. Todas as expressões precisa ter um tipo base comum, que é o tipo de item da matriz. Se uma matriz vazia for especificada com [], uma anotação de tipo poderá 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 dimensionada. Essa expressão é do formato [expr, size = s], em s que pode ser qualquer expressão do tipo Int e expr é avaliada como um valor que será os itens da matriz repetidamente s . Por exemplo, [1.2, size = 3] cria a mesma matriz que [1.2, 1.2, 1.2].

Literais de tupla

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

Literal de valor	Type
("Id", 0, 1.)	(String, Int, Double)
(PauliX,(3,1))	(Pauli, (Int, Int))

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

As tuplas são usadas para agrupar valores em um único valor, para que sejam passados com mais facilidade. Isso possibilita que cada chamável receba exatamente uma entrada e retorne exatamente uma saída.

Literais de tipos definidos pelo usuário

Os valores de um tipo definido pelo usuário são construídos invocando os respectivos construtores. Um construtor padrão é gerado automaticamente ao declarar o tipo. Atualmente, não é possível definir construtores personalizados.

Por exemplo, se IntPair tiver dois itens do tipo Int, então IntPair(2, 3) criará uma nova instância invocando o construtor padrão.

Literais de operação e função

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