Littéraux

Littéral Unit

Le seul littéral existant pour le type Unit est la valeur ().

La valeur Unit est couramment utilisée comme argument pour des callables (soit parce qu’aucun autre argument n’a besoin d’être transmis, soit pour retarder l’exécution). Elle est également utilisée comme valeur de retour quand aucune autre valeur n’a besoin d’être retournée, ce qui est le cas pour les opérations unitaires (opérations prenant en charge le foncteur Adjoint et/ou Controlled).

Littéraux Int

Les littéraux de valeur pour le type Int peuvent être exprimés en représentation binaire, octale, décimale ou hexadécimale. Les littéraux sont préfixés par 0b pour la représentation binaire, par 0o pour la représentation octale et par 0x pour la représentation hexadécimale. Il n’y a pas de préfixe pour la représentation décimale couramment utilisée.

Littéraux BigInt

Les littéraux de valeur pour le type BigInt sont toujours suffixés avec L et peuvent être exprimés en représentation binaire, octale, décimale ou hexadécimale. Les littéraux sont préfixés par 0b pour la représentation binaire, par 0o pour la représentation octale et par 0x pour la représentation hexadécimale. Il n’y a pas de préfixe pour la représentation décimale couramment utilisée.

Littéraux Double

Les littéraux de valeur pour le type Double peuvent être exprimés en notation standard ou scientifique.

Si rien ne suit le séparateur décimal, vous pouvez omettre le chiffre après le séparateur. Par exemple, 1. est un littéral Double valide qui équivaut à 1.0.

Littéraux Bool

Les littéraux existants pour le type Bool sont true et false.

Littéraux de chaîne

Un littéral de valeur pour le type String est une séquence de longueur arbitraire de caractères Unicode entre guillemets doubles. À l’intérieur d’une chaîne, le caractère de barre oblique inverse (\) peut être utilisé pour échapper un guillemet double ou pour insérer une nouvelle ligne (\n), un retour chariot (\r) et une tabulation (\t).

Voici des exemples de littéraux de chaîne valides :

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

Q# prend également en charge les chaînes interpolées. Une chaîne interpolée est un littéral de chaîne qui peut contenir n’importe quel nombre d’expressions d’interpolation. Ces expressions peuvent être de types arbitraires. Lors de la construction, les expressions sont évaluées et leur représentation String est insérée à l’emplacement correspondant dans le littéral défini. L’interpolation est activée en ajoutant le caractère spécial $ juste avant le guillemet initial, sans aucun espace blanc entre eux.

Par exemple, si res est une expression qui prend la valeur 1, la deuxième phrase du littéral String suivant affiche « The result was 1. » :

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

Littéraux Qubit

Il n’existe aucun littéral pour le type Qubit, car la mémoire quantique est gérée par le runtime. Les valeurs de type Qubit ne peuvent donc être obtenues que par allocation.

Les valeurs de type Qubit représentent un identificateur opaque par lequel un bit quantique, ou qubit, peut être adressé. Le seul opérateur pris en charge est la comparaison d’égalité. Pour plus d’informations sur le type de données Qubit, consultez Qubits.

Littéraux Result

Les littéraux existants pour le type Result sont Zero et One.

Les valeurs de type Result représentent le résultat d’une mesure quantique binaire. Zero indique une projection sur l’espace propre +1, One indique une projection sur l’espace propre -1.

Littéraux Pauli

Les littéraux existants pour le type Pauli sont PauliI, PauliX, PauliY et PauliZ.

Les valeurs de type Pauli représentent l’une des quatre matrices de Pauli à qubit unique, PauliI représentant l’identité. Les valeurs de type Pauli sont couramment utilisées pour désigner l’axe des rotations et spécifier la base par rapport à laquelle les mesures sont effectuées.

Littéraux Range

Les littéraux de valeur pour le type Range sont des expressions de la forme start..step..stop, où start, step et end sont des expressions de type Int. Si la taille du pas est 1, elle peut être omise. Par exemple, start..stop est un littéral Range valide qui équivaut à start..1..stop.

Les valeurs de type Range représentent une séquence d’entiers, où le premier élément de la séquence est start et où les éléments suivants sont obtenus en ajoutant step au précédent (jusqu’à ce que stop soit passé). Les valeurs Range sont inclusives aux deux extrémités, c’est-à-dire que le dernier élément de la plage est stop si la différence entre start et stop est un multiple de step. Une plage peut être vide si, par exemple, step est positif et que stop < start.

Voici des exemples de littéraux Range valides :

• 1..3 est la plage 1, 2, 3.
• 2..2..5 est la plage 2, 4.
• 2..2..6 est la plage 2, 4, 6.
• 6..-2..2 est la plage 6, 4, 2.
• 2..-2..1 est la plage 2.
• 2..1 est la plage vide.

Pour plus d’informations, consultez Expressions contextuelles.

Littéraux de tableau

Un littéral de tableau est une séquence de zéro ou plusieurs expressions, séparées par des virgules et placées entre crochets [ et ]; par exemple, [1,2,3]. Toutes les expressions doivent avoir un type de base commun, qui est le type d’élément du tableau. Si un tableau vide est spécifié avec [], une annotation de type peut être nécessaire pour que le compilateur détermine le type approprié de l’expression.

Des tableaux de longueur arbitraire peuvent être créés à l’aide d’une expression de tableau de taille. Une telle expression est de la forme [expr, size = s], où s peut être n’importe quelle expression de type Int et expr est évaluée à une valeur qui sera les éléments du tableau répétés s fois. Par exemple, [1.2, size = 3] crée le même tableau que [1.2, 1.2, 1.2].

Littéraux de tuple

Un littéral de tuple est une séquence entre parenthèses ( et ) d’une ou plusieurs expressions de n’importe quel type, séparées par des virgules. Le type du tuple inclut les informations sur chaque type d’élément.

Les tuples contenant un seul élément sont considérés comme identiques à l’élément lui-même, à la fois en type et en valeur, ce qui porte le nom d’équivalence de tuple singleton.

Les tuples sont utilisés pour regrouper des valeurs en une seule valeur pour faciliter leur passage. Cela permet à chaque callable de prendre exactement une entrée et de retourner exactement une sortie.

Littéraux pour les types définis par l’utilisateur

Les valeurs d’un type défini par l’utilisateur sont construites en appelant leur constructeur. Un constructeur par défaut est généré automatiquement lors de la déclaration du type. Il est actuellement impossible de définir des constructeurs personnalisés.

Par exemple, si IntPair a deux éléments de type Int, IntPair(2, 3) crée une instance en appelant le constructeur par défaut.

Littéraux d’opération et de fonction

Des opérations et fonctions anonymes peuvent être créées à l’aide d’une expression lambda.