Inférence de type

Cette rubrique décrit comment le compilateur F# déduit les types de valeurs, de variables, de paramètres et de valeurs de retour.

Inférence de type en général

L’idée d’inférence de type est que vous n’avez pas besoin de spécifier les types de constructions F#, sauf si le compilateur ne peut pas déduire de manière concluante le type. Omettre des informations de type explicites ne signifie pas que F# est un langage typé dynamiquement ou que les valeurs en F# sont faiblement typées. F# est un langage typé statiquement, ce qui signifie que le compilateur déduit un type exact pour chaque construction pendant la compilation. S’il n’y a pas suffisamment d’informations pour que le compilateur déduise les types de chaque construction, vous devez fournir des informations de type supplémentaires, généralement en ajoutant des annotations de type explicites quelque part dans le code.

Inférence des types de paramètres et de retour

Dans une liste de paramètres, vous n’avez pas besoin de spécifier le type de chaque paramètre. Pourtant, F# est un langage typé statiquement, et par conséquent, chaque valeur et expression a un type défini au moment de la compilation. Pour ces types que vous ne spécifiez pas explicitement, le compilateur déduit le type en fonction du contexte. Si le type n’est pas spécifié autrement, il est déduit d’être générique. Si le code utilise une valeur de façon incohérente, de telle sorte qu’il n’existe aucun type déduit unique qui satisfait à toutes les utilisations d’une valeur, le compilateur signale une erreur.

Le type de retour d’une fonction est déterminé par le type de la dernière expression dans la fonction.

Par exemple, dans le code suivant, les types a de paramètres et b le type de retour sont tous déduits int car le littéral 100 est de type int.

let f a b = a + b + 100

Vous pouvez influencer l’inférence de type en modifiant les littéraux. Si vous créez le 100 suffixe uint32 en ajoutant le suffixe u, les types de a, bet la valeur de retour est déduite comme uint32étant .

Vous pouvez également influencer l’inférence de type à l’aide d’autres constructions qui impliquent des restrictions sur le type, telles que des fonctions et des méthodes qui fonctionnent uniquement avec un type particulier.

En outre, vous pouvez appliquer des annotations de type explicites à des paramètres de fonction ou de méthode ou à des variables dans des expressions, comme illustré dans les exemples suivants. Des erreurs se produisent si des conflits se produisent entre différentes contraintes.

// Type annotations on a parameter.
let addu1 (x : uint32) y =
    x + y

// Type annotations on an expression.
let addu2 x y =
    (x : uint32) + y

Vous pouvez également spécifier explicitement la valeur de retour d’une fonction en fournissant une annotation de type après tous les paramètres.

let addu1 x y : uint32 =
   x + y

Un cas courant où une annotation de type est utile sur un paramètre est lorsque le paramètre est un type d’objet et que vous souhaitez utiliser un membre.

let replace(str: string) =
    str.Replace("A", "a")

Généralisation automatique

Si le code de fonction ne dépend pas du type d’un paramètre, le compilateur considère le paramètre comme générique. Ceci est appelé généralisation automatique, et il peut s’agir d’une aide puissante pour écrire du code générique sans augmenter la complexité.

Par exemple, la fonction suivante combine deux paramètres de n’importe quel type dans un tuple.

let makeTuple a b = (a, b)

Le type est déduit comme étant

'a -> 'b -> 'a * 'b

Informations supplémentaires

L’inférence de type est décrite plus en détail dans la spécification du langage F#.

Voir aussi

• Généralisation automatique