Référence des mots clés (F#)

Cette rubrique contient des liens vers des informations sur l'ensemble des mots clés du langage F#.

Tableau des mots clés du langage F#

Le tableau suivant répertorie tous les mots clés du langage F# par ordre alphabétique, offre de brèves descriptions de ces éléments, et fournit des liens vers des rubriques connexes contenant plus d'informations.

Mot clé	Link	Description
abstract	Membres (F#) Classes abstraites (F#)	Indique une méthode qui n'a aucune implémentation dans le type dans lequel elle est déclarée ou qui est virtuelle sans implémentation par défaut.
and	Liaisons let (F#) Membres (F#) Contraintes (F#)	Utilisé dans les liaisons mutuellement récursives, dans les déclarations de propriété et avec plusieurs contraintes sur des paramètres génériques.
as	Classes (F#) Critères spéciaux (F#)	Utilisé pour donner un nom d'objet à l'objet de classe actuel.Permet également de donner un nom à un modèle entier dans un critère spécial.
assert	Assertions (F#)	Utilisé pour vérifier le code au cours du débogage.
base	Classes (F#) Héritage (F#)	Utilisé comme nom de l'objet de classe de base.
begin	Syntaxe détaillée (F#)	Indique le début d'un bloc de code dans la syntaxe détaillée.
class	Classes (F#)	Indique le début d'une définition de classe dans la syntaxe détaillée.
default	Membres (F#)	Indique une implémentation d'une méthode abstraite. Utilisé avec une déclaration de méthode abstraite pour créer une méthode virtuelle.
delegate	Délégués (F#)	Permet de déclarer un délégué.
do	Liaisons do (F#) Boucles : expression for...to (F#) Boucles : expression for...in (F#) Boucles : expression while...do (F#)	Utilisé dans les constructions en boucle ou pour exécuter du code impératif.
done	Syntaxe détaillée (F#)	Indique la fin d'un bloc de code d'une expression en boucle dans la syntaxe détaillée.
downcast	Cast et conversions (F#)	Utilisé pour la conversion en un type de niveau inférieur dans la chaîne d'héritage.
downto	Boucles : expression for...to (F#)	Utilisé pour compter dans l'ordre inverse dans une expression for.
elif	Expressions conditionnelles : if... then...else (F#)	Utilisé dans le branchement conditionnel.Forme abrégée d'else if.
else	Expressions conditionnelles : if... then...else (F#)	Utilisé dans le branchement conditionnel.
end	Structures (F#) Unions discriminées (F#) Enregistrements (F#) Extensions de type (F#) Syntaxe détaillée (F#)	Indique la fin d'une section de définitions de membre dans les définitions et les extensions de type. Utilisé pour spécifier la fin d'un bloc de code qui commence par le mot clé begin dans la syntaxe détaillée.
exception	Gestion des exceptions (F#) Types d'exceptions (F#)	Utilisé pour déclarer un type d'exception.
extern	Fonctions externes (F#)	Indique qu'un élément de programme déclaré est défini dans un autre binaire ou assembly.
false	Types primitifs (F#)	Utilisé comme littéral booléen.
finally	Exceptions : expression try...finally (F#)	Utilisé avec try pour introduire un bloc de code qui s'exécute qu'une exception se produise ou non.
for	Boucles : expression for...to (F#) Boucles : expression for...in (F#)	Utilisé dans les constructions en boucle.
fun	Expressions lambda : mot clé fun (F#)	Utilisé dans les expressions lambda, aussi appelées fonctions anonymes.
function	Expressions match (F#) Expressions lambda : mot clé fun (F#)	Utilisé en guise d'alternative plus courte au mot clé fun et à une expression match dans une expression lambda possédant des critères spéciaux sur un argument unique.
global	Espaces de noms (F#)	Utilisé pour faire référence à l'espace de noms .NET de niveau supérieur.
if	Expressions conditionnelles : if... then...else (F#)	Utilisé dans les constructions de branchement conditionnel.
in	Boucles : expression for...in (F#) Syntaxe détaillée (F#)	Utilisé pour les expressions de séquence et, dans la syntaxe détaillée, pour séparer les expressions des liaisons.
inherit	Héritage (F#)	Utilisé pour spécifier une classe de base ou une interface de base.
inline	Fonctions (F#) Fonctions inline (F#)	Utilisé pour indiquer une fonction qui doit être directement intégrée dans le code de l'appelant.
interface	Interfaces (F#)	Utilisé pour déclarer et implémenter des interfaces.
internal	Contrôle d'accès (F#)	Utilisé pour spécifier qu'un membre est visible à l'intérieur d'un assembly, mais pas à l'extérieur de celui-ci.
lazy	Calculs tardifs (F#)	Utilisé pour spécifier un calcul qui doit être exécuté uniquement lorsqu'un résultat est exigé.
let	Liaisons let (F#)	Utilisé pour associer, ou lier, un nom à une valeur ou une fonction.
let!	Workflows asynchrones Expressions de calcul	Utilisé dans les flux de travail asynchrones pour lier un nom au résultat d'un calcul asynchrone, ou, dans d'autres expressions de calcul, utilisé pour lier un nom à un résultat, qui est de type de calcul.
match	Expressions match (F#)	Utilisé pour créer une branche en comparant une valeur à un modèle.
member	Membres (F#)	Utilisé pour déclarer une propriété ou une méthode dans un type d'objet.
module	Modules (F#)	Utilisé pour associer un nom à un groupe de types, valeurs et fonctions connexes, afin de le séparer logiquement d'autres segments de code.
mutable	Liaisons let (F#)	Utilisé pour déclarer une variable, c'est-à-dire une valeur pouvant être modifiée.
namespace	Espaces de noms (F#)	Utilisé pour associer un nom à un groupe de types et de modules connexes, afin de le séparer logiquement d'autres segments de code.
new	Constructeurs (F#) Contraintes (F#)	Utilisé pour déclarer, définir ou appeler un constructeur qui crée ou qui peut créer un objet. Également utilisé dans les contraintes de paramètre générique pour indiquer qu'un type doit avoir un certain constructeur.
not	Référence des symboles et opérateurs (F#) Contraintes (F#)	Il ne s'agit pas vraiment d'un mot clé.Toutefois, dans le cadre d'une combinaison, not struct est utilisé comme une contrainte de paramètre générique.
null	Valeurs Null (F#) Contraintes (F#)	Indique l'absence d'un objet. Également utilisé dans les contraintes de paramètre générique.
of	Unions discriminées (F#) Délégués (F#) Types d'exceptions (F#)	Utilisé dans les unions discriminées pour indiquer le type de catégories de valeurs, et dans les déclarations de délégué et d'exception.
open	Déclarations d'importation : mot clé open (F#)	Utilisé pour rendre le contenu d'un espace de noms ou d'un module disponible sans qualification.
or	Référence des symboles et opérateurs (F#) Contraintes (F#)	Utilisé avec des conditions booléennes en tant qu'opérateur or booléen.Équivalent à ||. Également utilisé dans les contraintes de membre.
override	Membres (F#)	Utilisé pour implémenter une version d'une méthode abstraite ou virtuelle qui diffère de la version de base.
private	Contrôle d'accès (F#)	Restreint l'accès à un membre au code dans le même type ou module.
public	Contrôle d'accès (F#)	Autorise l'accès à un membre en dehors du type.
rec	Fonctions (F#)	Utilisé pour indiquer qu'une fonction est récursive.
return	Workflows asynchrones (F#) Expressions de calcul (F#)	Utilisé pour indiquer une valeur à fournir comme résultat d'une expression de calcul.
return!	Expressions de calcul Workflows asynchrones	Utilisé pour indiquer une expression de calcul qui, lorsqu'elle est évaluée, fournit le résultat de l'expression conteneur de calcul.
select	Expressions de requête (F#)	Utilisé dans les expressions de requête pour spécifier les champs ou colonnes à récupérer.Notez qu'il est un mot clé contextuel, ce qui signifie qu'il n'est pas réellement un mot réservé et il agit uniquement comme un mot clé dans le contexte approprié.
static	Membres (F#)	Utilisé pour indiquer une méthode ou une propriété pouvant être appelée sans instance d'un type, ou un membre de valeur partagé entre toutes les instances d'un type.
struct	Structures (F#) Contraintes (F#)	Utilisé pour déclarer un type de structure. Également utilisé dans les contraintes de paramètre générique. Utilisé à des fins de compatibilité avec OCaml dans les définitions de module.
then	Expressions conditionnelles : if... then...else (F#) Constructeurs (F#)	Utilisé dans les expressions conditionnelles. Permet également d'exécuter des effets secondaires après la construction d'un objet.
to	Boucles : expression for...to (F#)	Utilisé dans les boucles for pour indiquer une plage.
true	Types primitifs (F#)	Utilisé comme littéral booléen.
try	Exceptions : expression try...with (F#) Exceptions : expression try...finally (F#)	Utilisé pour introduire un bloc de code pouvant générer une exception.Utilisé avec with ou finally.
type	Types F# Classes (F#) Enregistrements (F#) Structures (F#) Énumérations (F#) Unions discriminées (F#) Abréviations de types (F#) Unités de mesure (F#)	Utilisé pour déclarer une classe, un enregistrement, une structure, une union discriminée, un type énumération, une unité de mesure ou une abréviation de type.
upcast	Cast et conversions (F#)	Utilisé pour la conversion en un type de niveau supérieur dans la chaîne d'héritage.
use	Gestion des ressources : mot clé « use » (F#)	Utilisé à la place de let pour les valeurs qui nécessitent l'appel de Dispose pour libérer des ressources.
use!	Expressions de calcul Workflows asynchrones	Utilisé au lieu de let! dans les flux de travail asynchrones et autres expressions de calcul pour les valeurs qui nécessitent Dispose d'être appelé pour libérer les ressources.
val	Champs explicites : mot clé val (F#) Signatures (F#) Membres (F#)	Utilisé dans une signature pour indiquer une valeur, ou dans un type pour déclarer un membre, dans des situations limitées.
void	Types primitifs (F#)	Indique le type void .NET.Utilisé lors de l'interaction avec d'autres langages .NET.
when	Contraintes (F#)	Utilisé pour les conditions booléennes (gardes when) sur des critères spéciaux et pour introduire une clause de contrainte pour un paramètre de type générique.
while	Boucles : expression while...do (F#)	Introduit une construction en boucle.
with	Expressions match (F#) Expressions d'objet (F#) Extensions de type (F#) Exceptions : expression try...with (F#)	Utilisé avec le mot clé match dans les expressions de critères spéciaux.Également utilisé dans les expressions d'objet, les expressions de copie d'enregistrement et les extensions de type pour introduire des définitions de membre et des gestionnaires d'exceptions.
yield	Séquences (F#)	Utilisé dans une expression de séquence pour produire une valeur pour une séquence.
yield!	Expressions de calcul Workflows asynchrones	Utilisé dans une expression de calcul pour ajouter le résultat d'une expression de calcul donnée à une collection de résultats pour l'expression conteneur de calcul.

Par ailleurs, les jetons suivants sont réservés en F#, car ils correspondent à des mots clés dans le langage OCaml :

asr

land

lor

lsl

lsr

lxor

mod

sig

Si vous utilisez l'option de compilateur --mlcompatibility, ces mots clés sont disponibles en tant qu'identificateurs.

Les jetons suivants sont réservés en tant que mots clés dans le cadre de la future expansion du langage F# :

atomic	break	checked	component	const	constraint	constructor
continue	eager	event	external	fixed	functor	include
method	mixin	object	parallel	process	protected	pure
sealed	tailcall	trait	virtual	volatile

Voir aussi

Référence

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

Autres ressources

Référence du langage F#

Options du compilateur (F#)