# Literals

## Unit literal

The only existing literal for the `Unit`

type is the value `()`

.

The `Unit`

value is commonly used as an argument to callables, either because no other arguments need to be passed or to delay execution. It is also used as return value when no other value needs to be returned, which is the case for unitary operations, that is, operations that support the `Adjoint`

and/or the `Controlled`

functor.

## Int literals

Value literals for the `Int`

type can be expressed in binary, octal, decimal, or hexadecimal representation. Literals expressed in binary are prefixed with `0b`

, with `0o`

for octal, and with `0x`

for hexadecimal. There is no prefix for the commonly used decimal representation.

Representation | Value Literal |
---|---|

Binary | `0b101010` |

Octal | `0o52` |

Decimal | `42` |

Hexadecimal | `0x2a` |

## BigInt literals

Value literals for the `BigInt`

type are always postfixed with `L`

and can be expressed in binary, octal, decimal, or hexadecimal representation. Literals expressed in binary are prefixed with `0b`

, with `0o`

for octal, and with `0x`

for hexadecimal. There is no prefix for the commonly used decimal representation.

Representation | Value Literal |
---|---|

Binary | `0b101010L` |

Octal | `0o52L` |

Decimal | `42L` |

Hexadecimal | `0x2aL` |

## Double literals

Value literals for the `Double`

type can be expressed in standard or scientific notation.

Representation | Value Literal |
---|---|

Standard | `0.1973269804` |

Scientific | `1.973269804e-1` |

If nothing follows after the decimal point, then the digit after the decimal point may be omitted. For example, `1.`

is a valid `Double`

literal and the same as `1.0`

.

## Bool literals

Existing literals for the `Bool`

type are `true`

and `false`

.

## String literals

A value literal for the `String`

type is an arbitrary length sequence of Unicode characters enclosed in double quotes.
Inside of a string, the back-slash character `\`

may be used to escape
a double quote character, and to insert a new-line as `\n`

, a carriage
return as `\r`

, and a tab as `\t`

.

The following are examples for valid string literals:

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

Q# also supports *interpolated strings*.
An interpolated string is a string literal that may contain any number of interpolation expressions. These expressions can be of arbitrary types.
Upon construction, the expressions are evaluated and their `String`

representation is inserted at the corresponding location within the defined literal. Interpolation is enabled by prepending the special character `$`

directly before the initial quote, with no white space between them.

For instance, if `res`

is an expression that evaluates to `1`

, then the second sentence in the following `String`

literal displays "The result was 1.":

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

## Qubit literals

No literals for the `Qubit`

type exist, since quantum memory is managed by the runtime. Values of type `Qubit`

can hence only be obtained via allocation.

Values of type `Qubit`

represent an opaque identifier by which a quantum bit, or *qubit*, can be addressed. The only operator they support is equality comparison. For more information on the `Qubit`

data type, See Qubits.

## Result literals

Existing literals for the `Result`

type are `Zero`

and `One`

.

Values of type `Result`

represent the result of a binary quantum measurement.
`Zero`

indicates a projection onto the +1 eigenspace, `One`

indicates a projection onto the -1 eigenspace.

## Pauli literals

Existing literals for the `Pauli`

type are `PauliI`

, `PauliX`

, `PauliY`

, and `PauliZ`

.

Values of type `Pauli`

represent one of the four single-qubit Pauli matrices, with `PauliI`

representing the identity.
Values of type `Pauli`

are commonly used to denote the axis for rotations and to specify with respect to which basis to measure.

## Range literals

Value literals for the `Range`

type are expressions of the form `start..step..stop`

, where `start`

, `step`

, and `end`

are expressions of type `Int`

. If the step size is one, it may be omitted. For example, `start..stop`

is a valid `Range`

literal and the same as `start..1..stop`

.

Values of type `Range`

represent a sequence of integers, where the first element in the sequence is `start`

, and subsequent elements are obtained by adding `step`

to the previous one, until `stop`

is passed.
`Range`

values are inclusive at both ends, that is, the last element of the range is `stop`

if the difference between `start`

and `stop`

is a multiple of `step`

.
A range may be empty if, for instance, `step`

is positive and `stop < start`

.

The following are examples for valid `Range`

literals:

`1..3`

is the range 1, 2, 3.`2..2..5`

is the range 2, 4.`2..2..6`

is the range 2, 4, 6.`6..-2..2`

is the range 6, 4, 2.`2..-2..1`

is the range 2.`2..1`

is the empty range.

For more information, see Contextual expressions.

## Array literals

An array literal is a sequence of zero or more expressions, separated by commas and enclosed in brackets `[`

and `]`

; for example, `[1,2,3]`

.
All expressions must have a common base type, which is the item type of the array. If an empty array is specified with `[]`

, a type annotation may be needed for the compiler to determine the appropriate type of the expression.

Arrays of arbitrary length may be created using a sized-array expression.
Such an expression is of the form `[expr, size = s]`

, where `s`

can be any expression of type `Int`

and `expr`

is evaluated to a value that will be the items of the array repeated `s`

times. For example, `[1.2, size = 3]`

creates the same array as `[1.2, 1.2, 1.2]`

.

## Tuple literals

A tuple literal is a sequence of one or more expressions of any type, separated by commas and enclosed in parentheses `(`

and `)`

. The type of the tuple includes the information about each item type.

Value Literal | Type |
---|---|

`("Id", 0, 1.)` |
`(String, Int, Double)` |

`(PauliX,(3,1))` |
`(Pauli, (Int, Int))` |

Tuples containing a single item are treated as identical to the item itself, both in type and value, which is called singleton tuple equivalence.

Tuples are used to bundle values together into a single value, making it easier to pass them around. This makes it possible for every callable to take exactly one input and return exactly one output.

## Literals for struct types

Values of a struct type are assigned when you create a new instance, using either the `new`

statement or the constructor created by the compiler.

For example, if `IntPair`

is a `struct`

defined as

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

then you create a new instance and assign values using

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

or

```
let MyPair = IntPair(5, 7);
```

## Operation and function literals

Anonymous operations and functions can be created using a lambda expression.