Types F#

Cette rubrique décrit les types utilisés en F# et explique comment ils sont nommés et décrits.

Résumé des types F#

Certains types sont considérés comme des types primitifs, tels que le type booléen bool et les types intégraux et à virgule flottante de différentes tailles, qui incluent les types pour les octets et les caractères. Ces types sont décrits dans la section Types primitifs (F#).

Les autres types intégrés au langage incluent les tuples, les listes, les tableaux, les séquences, les enregistrements et les unions discriminées. Si vous connaissez déjà d'autres langages .NET et que vous apprenez F#, nous vous recommandons de lire les rubriques sur chacun de ces types. Pour plus d'informations sur ces types, consultez les liens dans la section Rubriques connexes de cette rubrique. Les types propres au langage F# prennent en charge des styles de la programmation qui sont communs aux langages de programmation fonctionnelle. La plupart de ces types ont des modules associés dans la bibliothèque F# qui prennent en charge des opérations communes sur ces types.

Le type d'une fonction comprend des informations sur les types de paramètre et le type de retour.

Le .NET Framework est la source des types d'objet, des types d'interface, des types délégués, etc. Vous pouvez définir vos propres types d'objet comme dans tout autre langage .NET.

Par ailleurs, le code F# peut définir des alias, appelés abréviations de type, qui sont des noms de remplacement pour les types. Vous pouvez utiliser des abréviations de type lorsque le type est susceptible d'être modifié et que voulez éviter de modifier le code qui dépend du type. Vous pouvez également utiliser une abréviation de type comme nom convivial d'un type afin de rendre le code plus lisible.

F# fournit les types de collection utiles conçus avec la programmation fonctionnelle à l'esprit. À l'aide de ces types de collection vous écrivez du code qui est plus fonctionnelles dans le style. Pour plus d’informations, consultez Types de collection F#.

Syntaxe pour les types

Dans le code F#, vous devez souvent écrire les noms des types. Chaque type a une forme syntaxique, que vous utilisez dans les annotations de type, les déclarations de méthode abstraites, les déclarations de délégués, les signatures et d'autres constructions. Chaque fois que vous déclarez une nouvelle construction de programme dans l'interpréteur, ce dernier imprime le nom de la construction et la syntaxe pour son type. Cette syntaxe peut simplement se composer d'un identificateur pour un type défini par l'utilisateur ou d'un identificateur intégré, par exemple pour int ou string. Toutefois, pour des types plus complexes, la syntaxe est plus compliquée.

Le tableau suivant indique les aspects de la syntaxe de type pour les types F#.

Type	Syntaxe de type	Exemples
Type primitif	type-name	int float string
type d'agrégat (classe, structure, union, enregistrement, enum, etc.)	type-name	System.DateTime Color
abréviation de type	type-abbreviation-name	bigint
type qualifié complet	namespaces.type-name ou modules.type-name ou namespaces.modules.type-name	System.IO.StreamWriter
Tableau	type-name[] or Tableau type-name	int[] array<int> int array
tableau à deux dimensions	type-name[,]	int[,] float[,]
tableau à trois dimensions	type-name[,,]	float[,,]
tuple	type-name1 * type-name2 ...	Par exemple, (1,'b',3) a le type int * char * int
type générique	type-parameter generic-type-name ou generic-type-name<type-parameter-list>	'a list list<'a> Dictionary<'key, 'value>
type construit (type générique pour lequel un argument de type spécifique est fourni)	type-argument generic-type-name ou generic-type-name<type-argument-list>	int option string list int ref option<int> list<string> ref<int> Dictionary<int, string>
type de fonction qui a un paramètre unique	parameter-type1 -> return-type	Une fonction qui prend int et retourne string a le type int -> string
type de fonction qui a plusieurs paramètres	parameter-type1 -> parameter-type2 -> ... -> return-type	Une fonction qui prend int et float et qui retourne string a le type int -> float -> string.
fonction d'ordre supérieur en tant que paramètre	(function-type)	List.map a le type ('a -> 'b) -> 'a list -> 'b list.
délégué	délégué de function-type	delegate of unit -> int
type flexible	#type-name	#System.Windows.Forms.Control #seq<int>

Rubriques connexes

Rubrique	Description
Types primitifs (F#)	Décrit des types simples intégrés, tels que les types intégraux, le type booléen et les types de caractères.
Type unit (F#)	Décrit le type unit, un type qui a une valeur et qui est indiqué par () ; équivaut à void en C# et à Nothing en Visual Basic.
Tuples (F#)	Décrit le type de tuple, un type qui se compose de valeurs associées de n'importe quel type groupées en paires, triples, quadruples, et ainsi de suite.
Options (F#)	Décrit le type d'option, un type qui peut avoir une valeur ou être vide.
Listes (F#)	Décrit les listes, qui sont des séries immuables et ordonnées d'éléments du même type.
Tableaux (F#)	Décrit les tableaux, qui sont des jeux ordonnés d'éléments mutables du même type qui occupent un bloc de mémoire contigu et qui sont de taille fixe.
Séquences (F#)	Décrit le type de séquence, qui représente une série logique de valeurs ; les valeurs individuelles sont uniquement calculées en fonction des besoins.
Enregistrements (F#)	Décrit le type d'enregistrement, un petit agrégat de valeurs nommées.
Unions discriminées (F#)	Décrit le type d'union discriminé, un type dont les valeurs peuvent être l'une des valeurs d'un jeu de types possibles.
Fonctions (F#)	Décrit les valeurs de fonction.
Classes (F#)	Décrit le type de classe, un type d'objet qui correspond à un type référence .NET. Les types de classe peuvent contenir des membres, des propriétés, des interfaces implémentées et un type de base.
Structures (F#)	Décrit le type struct, un type d'objet qui correspond à un type valeur .NET. Le type struct représente habituellement un petit agrégat de données.
Interfaces (F#)	Décrit les types d'interface, qui sont des types représentant un jeu de membres qui fournissent certaines fonctionnalités, mais qui ne contiennent pas de données. Un type d'interface doit être implémenté par un type d'objet pour être utile.
Délégués (F#)	Décrit le type délégué, qui représente une fonction comme un objet.
Énumérations (F#)	Décrit les types d'énumération, dont les valeurs appartiennent à un jeu de valeurs nommées.
Attributs (F#)	Décrit les attributs, qui sont utilisés pour spécifier des métadonnées pour un autre type.
Types d'exceptions (F#)	Décrit les exceptions, qui spécifient des informations sur les erreurs.