Literales

Literal Unit

El único literal que existe para el tipo Unit es el valor ().

El valor Unit se usa normalmente como argumento para los elementos invocables, ya sea porque no es necesario pasar ningún otro argumento o para retrasar la ejecución. También se usa como valor devuelto cuando no es necesario devolver ningún otro valor, que es el caso de las operaciones unitarias, es decir, las operaciones que admiten los functores Adjoint o Controlled.

Literales Int

Los literales de valor para el tipo Int se pueden expresar en formato binario, octal, decimal o hexadecimal. Los literales binarios incluyen el prefijo 0b, los octales el prefijo 0o y los hexadecimales el prefijo 0x. No hay ningún prefijo para el formato decimal usado con frecuencia.

Representación	Literal de valor
Binary	0b101010
Octal	0o52
Decimal	42
Hexadecimal	0x2a

Literales BigInt

Los literales de valor para el tipo BigInt siempre incluyen el postfijo L y se pueden expresar en formato binario, octal, decimal o hexadecimal. Los literales binarios incluyen el prefijo 0b, los octales el prefijo 0o y los hexadecimales el prefijo 0x. No hay ningún prefijo para el formato decimal usado con frecuencia.

Representación	Literal de valor
Binary	0b101010L
Octal	0o52L
Decimal	42L
Hexadecimal	0x2aL

Literales Double

Los literales de valor para el tipo Double se pueden expresar en notación estándar o científica.

Representación	Literal de valor
Estándar	0.1973269804
Científico	1.973269804e-1

Si no hay nada después del separador decimal, se puede omitir el dígito después del separador. Por ejemplo, 1. es un literal válido de tipo Double y es el mismo que 1.0.

Literales de tipo Bool

Los literales que existen para el tipo Bool son true y false.

Literales de cadena

Un literal de valor para el tipo String es una secuencia de longitud arbitraria de caracteres Unicode entre comillas dobles. Dentro de una cadena, el carácter de barra invertida \ se puede usar para evitar un carácter de comilla doble, así como para agregar una nueva línea como \n, un retorno de carro como \r y una pestaña como \t.

A continuación se muestran ejemplos de literales de cadena válidos:

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

Q# también admite cadenas interpoladas. Una cadena interpolada es un literal de cadena que puede contener expresiones de interpolación. Estas expresiones pueden ser de tipos arbitrarios. Tras la construcción, se evalúan las expresiones y su representación String se agrega en la ubicación correspondiente dentro del literal definido. La interpolación se habilita anteponiendo el carácter especial $ directamente antes de las comillas iniciales, sin ningún espacio en blanco entre ellos.

Por ejemplo, si res es una expresión que se evalúa como 1, la segunda frase del literal String siguiente muestra "El resultado fue 1.":

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

Literales de tipo Qubit

No existen literales para el tipo Qubit, ya que el tiempo de ejecución administra la memoria cuántica. Por lo tanto, los valores de tipo Qubit solo se pueden obtener a través de asignación.

Los valores de tipo Qubit representan un identificador opaco por el que se puede hacer referencia a un bit cuántico, o cúbit. El único operador que admiten es la comparación de igualdad. Para más información sobre el tipo de datos Qubit, consulte Cúbits.

Literales de tipo Result

Los literales que existen para el tipo Result son Zero y One.

Los valores de tipo Result representan el resultado de una medida cuántica binaria. Zero indica una proyección en el espacio propio +1, One indica una proyección en el espacio propio -1.

Literales de tipo Pauli

Los literales que existen para el tipo Pauli son PauliI, PauliX, PauliY y PauliZ.

Los valores de tipo Pauli representan una de las cuatro matrices de Pauli de un solo cúbit, donde PauliI representa la identidad. Los valores de tipo Pauli se usan normalmente para indicar el eje para las rotaciones y para especificar con respecto a qué base medir.

Literales de tipo Range

Los literales de valor para el tipo Range son expresiones con el formato start..step..stop, donde start, step y end son expresiones de tipo Int. Si el tamaño del paso es uno, se puede omitir. Por ejemplo, start..stop es un literal válido de tipo Range y es el mismo que start..1..stop.

Los valores de tipo Range representan una secuencia de enteros, donde el primer elemento de la secuencia es start y los elementos posteriores se obtienen agregando step al anterior, hasta que se pasa stop. Los valores de tipo Range son inclusivos en ambos extremos, es decir, el último elemento del intervalo es stop si la diferencia entre start y stop es un múltiplo de step. Un intervalo puede estar vacío si, por ejemplo, step es positivo y stop < start.

A continuación se muestran ejemplos de literales de Range válidos:

• 1..3 es el intervalo 1, 2, 3.
• 2..2..5 es el intervalo 2, 4.
• 2..2..6 es el intervalo 2, 4, 6.
• 6..-2..2 es el intervalo 6, 4, 2.
• 2..-2..1 es el intervalo 2.
• 2..1 es el intervalo vacío.

Para más información, consulte Expresiones contextuales.

Literales de matriz

Un literal de matriz es una secuencia de cero o más expresiones, separadas por comas y entre corchetes [ y ]; por ejemplo, [1,2,3]. Todas las expresiones deben tener un tipo base común, que es el tipo de elemento de la matriz. Si se especifica una matriz vacía con [], es posible que se necesite una anotación de tipo para que el compilador determine el tipo adecuado de la expresión.

Las matrices de longitud arbitraria se pueden crear mediante una expresión de matriz de tamaño. Esta expresión tiene el formato [expr, size = s], donde s puede ser cualquier expresión de tipo Int y expr se evalúa como un valor que será los elementos de la matriz repetidas s veces. Por ejemplo, [1.2, size = 3] crea la misma matriz que [1.2, 1.2, 1.2].

Literales de tupla

Un literal de tupla es una secuencia de una o varias expresiones de cualquier tipo entre paréntesis ( y ) separadas por comas. El tipo de tupla incluye información sobre cada tipo de elemento.

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

Las tuplas que contienen un solo elemento se tratan como idénticas al propio elemento, tanto en cuanto al tipo como al valor, lo que se conoce como equivalencia de tupla singleton.

Las tuplas se usan para agrupar valores en un solo valor, lo que facilita su paso. Esto hace posible que cada elemento invocable tome exactamente una entrada y devuelva exactamente una salida.

Literales para tipos definidos por el usuario

Los valores de un tipo definido por el usuario se construyen invocando a su constructor. Al declarar el tipo, se genera automáticamente un constructor predeterminado. Actualmente no es posible definir constructores personalizados.

Por ejemplo, si IntPair tiene dos elementos de tipo Int, IntPair(2, 3) crea una nueva instancia invocando al constructor predeterminado.

Literales de operación y función

Las operaciones y funciones anónimas se pueden crear mediante una expresión lambda.