Référence des symboles et opérateurs (F#)

Cette rubrique inclut un tableau des symboles et des opérateurs utilisés en F#.

Tableau des symboles et des opérateurs

Le tableau suivant décrit les symboles utilisés dans le langage F#, fournit des liens vers les rubriques qui proposent des informations supplémentaires et donne une brève description de certaines utilisations du symbole. Les symboles sont classés selon l'ordre du jeu de caractères ASCII.

Symbole ou opérateur	Liens	Description
!	Cellules de référence (F#) Expressions de calcul (F#)	Déréférence une cellule de référence. Après un mot clé, indique une version modifiée du comportement du mot clé sous le contrôle d'un flux de travail.
!=	Non applicable.	Non utilisé en F#. Utilisez <> pour les opérations d'inégalité.
"	Littéraux (F#) Chaînes (F#)	Délimite une chaîne de texte.
"""	Chaînes (F#)	Délimite une chaîne textuelle. Diffère de @"..." en ce sens que vous pouvez indiquer un caractère guillemet anglais en utilisant un seul guillemet dans la chaîne.
#	Directives de compilateur (F#) Types flexibles (F#)	Préfixe une directive de préprocesseur ou de compilateur, telle que #light. Lorsqu'il est utilisé avec un type, indique un type flexible, qui fait référence à un type ou à l'un de ses types dérivés.
$	Aucune information supplémentaire n'est disponible.	Utilisé en interne pour certains noms de variable et de fonction générés par le compilateur.
%	Opérateurs arithmétiques (F#) Quotations de code (F#)	Calcule le modulo entier. Utilisée pour les expressions d'ajout dans les quotations de code typé.
%%	Quotations de code (F#)	Utilisée pour les expressions d'ajout dans les quotations de code non typé.
%?	Opérateurs autorisant la valeur Null (F#)	Calcule le modulo entier lorsque la partie droite est un type Nullable.
&	Expressions match (F#)	Calcule l'adresse d'une valeur mutable pour une utilisation lors de l'interaction avec d'autres langages. Utilisé dans les modèles AND.
&&	Opérateurs booléens (F#)	Calcule l'opération booléenne AND.
&&&	Opérateurs de bits (F#)	Calcule l'opération AND au niveau du bit.
'	Littéraux (F#) Généralisation automatique (F#)	Délimite un littéral à un seul caractère. Indique un paramètre de type générique.
``...``	Aucune information supplémentaire n'est disponible.	Délimite un identificateur qui, sinon, ne serait pas un identificateur légal, tel qu'un mot clé du langage.
( )	Type unit (F#)	Représente la valeur unique du type d'unité.
(...)	Tuples (F#) Surcharge d'opérateur (F#)	Indique l'ordre dans lequel les expressions sont analysées. Délimite un tuple. Utilisé dans les définitions d'opérateur.
(*...*)		Délimite un commentaire qui peut couvrir plusieurs lignes.
(|...|)	Modèles actifs (F#)	Délimite un modèle actif. Également appelé « banana clips ».
*	Opérateurs arithmétiques (F#) Tuples (F#) Unités de mesure (F#)	Lorsqu'il est utilisé comme un opérateur binaire, multiplie les côtés gauche et droit. Dans les types, indique un jumelage dans un tuple. Utilisé dans les types d'unités de mesure.
*?	Opérateurs autorisant la valeur Null (F#)	Multiplie les côtés gauche et droit, lorsque la partie droite est un type Nullable.
**	Opérateurs arithmétiques (F#)	Calcule l'opération d'élévation à la puissance (x ** y signifie x puissance y).
+	Opérateurs arithmétiques (F#)	Lorsqu'il est utilisé comme opérateur binaire, ajoute les côtés gauche et droit. Lorsqu'il est utilisé comme opérateur unaire, indique une quantité positive. (Formellement, il produit la même valeur avec le signe inchangé.)
+?	Opérateurs autorisant la valeur Null (F#)	Ajoute les côtés gauche et droit, lorsque la partie droite est un type Nullable.
,	Tuples (F#)	Sépare les éléments d'un tuple, ou les paramètres de type.
-	Opérateurs arithmétiques (F#)	Lorsqu'il est utilisé comme opérateur binaire, soustrait le côté droit du côté gauche. Lorsqu'il est utilisé comme opérateur unaire, effectue une opération de négation.
-	Opérateurs autorisant la valeur Null (F#)	Soustrait le côté droit du côté gauche, lorsque la partie droite est un type Nullable.
->	Fonctions (F#) Expressions match (F#)	Dans les types de fonction, délimite les arguments et les valeurs de retour. Génère une expression (dans les expressions de séquence) ; équivalent au mot clé yield. Utilisé dans les expressions de correspondance
.	Membres (F#) Types primitifs (F#)	Accède à un membre et sépare les noms individuels dans un nom complet. Spécifie une virgule décimale dans les nombres à virgule flottante.
..	Boucles : expression for...in (F#)	Spécifie une plage.
.. ..	Boucles : expression for...in (F#)	Spécifie une plage et un incrément.
.[...]	Tableaux (F#)	Accède à un élément de tableau.
/	Opérateurs arithmétiques (F#) Unités de mesure (F#)	Divise le côté gauche (numérateur) par le côté droit (dénominateur). Utilisé dans les types d'unités de mesure.
/?	Opérateurs autorisant la valeur Null (F#)	Divise le côté gauche par le côté droit lorsque ce dernier est un type Nullable.
//		Indique le début d'un commentaire sur une ligne.
///	Documentation XML (F#)	Indique un commentaire XML.
:	Fonctions (F#)	Dans une annotation de type, sépare un nom de paramètre ou de membre de son type.
::	Listes (F#) Expressions match (F#)	Crée une liste. L'élément côté gauche est ajouté à la liste côté droit. Utilisé dans les critères spéciaux pour séparer les parties d'une liste.
:=	Cellules de référence (F#)	Assigne une valeur à une cellule de référence.
:>	Cast et conversions (F#)	Convertit un type en un type placé plus haut dans la hiérarchie.
:?	Expressions match (F#)	Retourne true si la valeur correspond au type spécifié ; sinon, retournefalse (opérateur de test de type).
:?>	Cast et conversions (F#)	Convertit un type en un type placé plus bas dans la hiérarchie.
;	Syntaxe détaillée (F#) Listes (F#) Enregistrements (F#)	Sépare les expressions (utilisé principalement dans la syntaxe des commentaires). Sépare les éléments d'une liste. Sépare les champs d'un enregistrement.
<	Opérateurs arithmétiques (F#)	Calcule l'opération « inférieur à ».
<?	Opérateurs autorisant la valeur Null (F#)	Calcule l'opération « inférieur à » lorsque la partie droite est un type Nullable.
<<	Fonctions (F#)	Compose deux fonctions dans l'ordre inverse ; la deuxième est exécutée en premier (opérateur de composition arrière).
<<<	Opérateurs de bits (F#)	Décale les bits de la quantité côté gauche vers la gauche selon le nombre de bits spécifié côté droit.
<-	Valeurs (F#)	Assigne une valeur à une variable.
<...>	Généralisation automatique (F#)	Délimite les paramètres de type.
<>	Opérateurs arithmétiques (F#)	Retourne true si le côté gauche n'est pas égal au côté droit ; sinon, retourne false.
<>?	Opérateurs autorisant la valeur Null (F#)	Calcule l'opération « non égal à » lorsque la partie droite est un type Nullable.
<=	Opérateurs arithmétiques (F#)	Retourne true si le côté gauche est inférieur ou égal au côté droit ; sinon, retourne false.
<=?	Opérateurs autorisant la valeur Null (F#)	Calcule l'opération « inférieur ou égal à » lorsque la partie droite est un type Nullable.
<|	Fonctions (F#)	Passe le résultat de l'expression côté droit à la fonction côté gauche (opérateur de barre verticale inverse).
<||	Operators.( <|| )<'T1,'T2,'U>, fonction (F#)	Transmet le tuple de deux arguments côté droit à la fonction côté gauche.
<|||	Operators.( <||| )<'T1,'T2,'T3,'U>, fonction (F#)	Transmet le tuple de trois arguments côté droit à la fonction côté gauche.
<@...@>	Quotations de code (F#)	Délimite une quotation de code typé.
<@@...@@>	Quotations de code (F#)	Délimite une quotation de code non typé.
=	Opérateurs arithmétiques (F#)	Retourne true si le côté gauche est égal au côté droit ; sinon, retourne false.
=?	Opérateurs autorisant la valeur Null (F#)	Calcule l'opération « égal à » lorsque la partie droite est un type Nullable.
==	Non applicable.	Non utilisé en F#. Utilisez = pour les opérations d'égalité.
>	Opérateurs arithmétiques (F#)	Retourne true si le côté gauche est supérieur au côté droit ; sinon, retourne false.
>?	Opérateurs autorisant la valeur Null (F#)	Calcule l'opération « supérieur à » lorsque la partie droite est un type Nullable.
>>	Fonctions (F#)	Compose deux fonctions (opérateur de composition avant).
>>>	Opérateurs de bits (F#)	Décale les bits de la quantité côté gauche vers la droite selon le nombre d'emplacements spécifié côté droit.
>=	Opérateurs arithmétiques (F#)	Retourne true si le côté droit est supérieur ou égal au côté gauche ; sinon, retourne false.
>=?	Opérateurs autorisant la valeur Null (F#)	Calcule l'opération « supérieur ou égal à » lorsque la partie droite est un type Nullable.
?	Paramètres et arguments (F#)	Spécifie un argument facultatif. Utilisé comme opérateur pour les appels de méthodes et de propriétés dynamiques. Vous devez fournir votre propre implémentation.
? ... <- ...	Aucune information supplémentaire n'est disponible.	Utilisé comme opérateur pour définir les propriétés dynamiques. Vous devez fournir votre propre implémentation.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Opérateurs autorisant la valeur Null (F#)	Équivaut aux opérateurs correspondants sans le préfixe ? , où un type Nullable est situé à gauche.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Opérateurs autorisant la valeur Null (F#)	Équivaut aux opérateurs correspondants sans le suffixe ? , où un type Nullable est situé à droite.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Opérateurs autorisant la valeur Null (F#)	Équivalent aux opérateurs correspondants sans les points d'interrogation, où les deux côtés sont des types Nullables.
@	Listes (F#) Chaînes (F#)	Concatène deux listes. Lorsqu'il est placé avant un littéral de chaîne, indique que la chaîne doit être interprétée textuellement, sans interprétation des caractères d'échappement.
[...]	Listes (F#)	Délimite les éléments d'une liste.
[|...|]	Tableaux (F#)	Délimite les éléments d'un tableau.
[<...>]	Attributs (F#)	Délimite un attribut.
\	Chaînes (F#)	Échappe le caractère suivant ; utilisé dans les littéraux de caractère et de chaîne.
^	Paramètres de type résolus statiquement (F#) Chaînes (F#)	Spécifie les paramètres de type qui doivent être résolus au moment de la compilation, pas au moment de l'exécution. Concatène les chaînes.
^^^	Opérateurs de bits (F#)	Calcule l'opération OR exclusif au niveau du bit.
_	Expressions match (F#) Génériques (F#)	Indique un modèle de caractère générique. Spécifie un paramètre générique anonyme.
`	Généralisation automatique (F#)	Utilisé en interne pour indiquer un paramètre de type générique.
{...}	Séquences (F#) Enregistrements (F#)	Délimite les expressions de séquence et les expressions de calcul. Utilisé dans les définitions d'enregistrement.
|	Expressions match (F#)	Délimite les cas de correspondance individuels, les cas d'union discriminés individuels et les valeurs d'énumération.
||	Opérateurs booléens (F#)	Calcule l'opération booléenne OR.
|||	Opérateurs de bits (F#)	Calcule l'opération OR au niveau du bit.
|>	Fonctions (F#)	Passe le résultat du côté gauche de la fonction au côté droit (opérateur de canal avant).
||>	Operators.( ||> )<'T1,'T2,'U>, fonction (F#)	Transmet le tuple de deux arguments côté gauche à la fonction côté droit.
|||>	Operators.( |||> )<'T1,'T2,'T3,'U>, fonction (F#)	Transmet le tuple de trois arguments côté gauche à la fonction côté droit.
~~	Surcharge d'opérateur (F#)	Permet de déclarer une surcharge pour l'opérateur de négation unaire.
~~~	Opérateurs de bits (F#)	Calcule l'opération NOT au niveau du bit.
~-	Surcharge d'opérateur (F#)	Permet de déclarer une surcharge pour l'opérateur moins unaire.
~+	Surcharge d'opérateur (F#)	Permet de déclarer une surcharge pour l'opérateur plus unaire.

Priorité des opérateurs

Le tableau suivant indique l'ordre de priorité des opérateurs et autres mots clés d'expression en langage F#, de la priorité la plus basse à la priorité la plus élevée. L'associativité est également mentionnée, le cas échéant.

Opérateur	Associativité
as	Droit
when	Droit
| (barre verticale)	Left
;	Droit
let	Non associatif
function, fun, match, try	Non associatif
if	Non associatif
->	Droit
:=	Droit
,	Non associatif
or, ||	Left
&, &&	Left
<op, >op, =, |op, &op	Left
&&&, |||, ^^^, ~~~, <<<, >>>	Left
^op	Droit
::	Droit
:?>, :?	Non associatif
-op, +op, (binaire)	Left
*op, /op, %op	Left
**op	Droit
f x (application de fonction)	Left
| (critères spéciaux)	Droit
opérateurs de préfixe (+op, -op, %, %%, &, &&, !op, ~op)	Left
.	Left
f(x)	Left
f<types>	Left

F# prend en charge la surcharge d'opérateur personnalisé. Cela signifie que vous pouvez définir vos propres opérateurs. Dans le tableau précédent, op peut être une séquence valide (éventuellement vide) de caractères d'opérateur, intégrée ou définie par l'utilisateur. Par conséquent, vous pouvez utiliser ce tableau pour déterminer la séquence de caractères à utiliser pour un opérateur personnalisé et atteindre ainsi le niveau de priorité souhaité. Les caractères . de tête sont ignorés lorsque le compilateur détermine les priorités.

Voir aussi

Référence

Surcharge d'opérateur (F#)

Autres ressources

Référence du langage F#