All elements of an array must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n {1} \nThis element is a tuple of length {2} of type\n {3} \n Tous les éléments d’un tableau doivent être implicitement convertibles en type du premier élément, qui est ici un tuple de longueur {0} de type\n {1} \nCet élément est un tuple de longueur {2} de type\n {3} \n The source file '{0}' (at position {1}/{2}) already appeared in the compilation list (at position {3}/{4}). Please verify that it is included only once in the project file. Le fichier source « {0} » (à la position {1}/{2}) apparaît déjà dans la liste de compilation (à la position {3}/{4}). Vérifiez qu’il n’est inclus qu’une seule fois dans le fichier projet. The file extension of '{0}' is not recognized. Source files must have extension .fs, .fsi, .fsx or .fsscript. To enable the deprecated use of .ml or .mli extensions, use '--langversion:5.0' and '--mlcompatibility'. L’extension de fichier « {0} » n’est pas reconnue. Les fichiers sources doivent avoir l’extension. FS,. FSI,. FSX ou. fsscript. Pour activer l’utilisation déconseillée des extensions. ml ou. MLI, utilisez'--langversion : 5.0 'et'--mlcompatibility'. The file extension of '{0}' is not recognized. Source files must have extension .fs, .fsi, .fsx or .fsscript L'extension de fichier de '{0}' n'est pas reconnue. Les fichiers sources doivent avoir l'extension .fs, .fsi, .fsx, ou .fsscript. If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Abstract member declarations are not allowed. Si un type utilise à la fois les attributs [<Sealed>] et [<AbstractClass>], cela signifie qu'il est statique. Les déclarations abstraites des membres ne sont pas autorisées. If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Additional constructor is not allowed. Si un type utilise les attributs [<Sealed>] et [<AbstractClass>], cela signifie qu’il est statique. Un constructeur supplémentaire n’est pas autorisé. FSharp.Core.AutoOpenAttribute should not be aliased. FSharp.Core.AutoOpenAttribute ne doit pas avoir d'alias. If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Constructor with arguments is not allowed. Si un type utilise les attributs [<Sealed>] et [<AbstractClass>], cela signifie qu’il est statique. Le constructeur avec des arguments n’est pas autorisé. Duplicate parameter. The parameter '{0}' has been used more that once in this method. Paramètre dupliqué. Le paramètre « {0} » a été utilisé une fois de plus dans cette méthode. If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Explicit field declarations are not allowed. Si un type utilise à la fois les attributs [<Sealed>] et [<AbstractClass>], cela signifie qu'il est statique. Les déclarations de champs explicites ne sont pas autorisées. Feature '{0}' is not available in F# {1}. Please use language version {2} or greater. La fonctionnalité '{0}' n'est pas disponible en F# {1}. Utilisez la version de langage {2} ou une version ultérieure. Feature '{0}' is not supported by target runtime. La fonctionnalité '{0}' n'est pas prise en charge par le runtime cible. Feature '{0}' requires the F# library for language version {1} or greater. La fonctionnalité '{0}' nécessite la bibliothèque F# pour le langage version {1} ou ultérieure. If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Implementing interfaces is not allowed. Si un type utilise à la fois les attributs [<Sealed>] et [<AbstractClass>], cela signifie qu'il est statique. L'implémentation d'interfaces n'est pas autorisée. The use of ':=' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'cell := expr' to 'cell.Value <- expr'. L’utilisation de « := » à partir de la bibliothèque F# est déconseillée. Voir https://aka.ms/fsharp-refcell-ops. Par exemple, veuillez remplacer « cell := expr » par « cell.Value <- expr ». The use of 'decr' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'decr cell' to 'cell.Value <- cell.Value - 1'. L’utilisation de « decr » à partir de la bibliothèque F# est déconseillée. Voir https://aka.ms/fsharp-refcell-ops. Par exemple, veuillez remplacer « decr cell » par « cell.Value <- cell.Value - 1 ». The use of '!' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change '!cell' to 'cell.Value'. L’utilisation de « ! » à partir de la bibliothèque F# est déconseillée. Voir https://aka.ms/fsharp-refcell-ops. Par exemple, veuillez remplacer « !cell » par « cell.Value ». The use of 'incr' from the F# library is deprecated. See https://aka.ms/fsharp-refcell-ops. For example, please change 'incr cell' to 'cell.Value <- cell.Value + 1'. L’utilisation de « incr » à partir de la bibliothèque F# est déconseillée. Voir https://aka.ms/fsharp-refcell-ops. Par exemple, veuillez remplacer « incr cell » par « cell.Value <- cell.Value + 1 ». If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance let bindings are not allowed. Si un type utilise à la fois les attributs [<Sealed>] et [<AbstractClass>], cela signifie qu'il est statique. Les liaisons let d'instance ne sont pas autorisées. If a type uses both [<Sealed>] and [<AbstractClass>] attributes, it means it is static. Instance members are not allowed. Si un type utilise les attributs [<Sealed>] et [<AbstractClass>], cela signifie qu’il est statique. Les membres de l’instance ne sont pas autorisés. The 'AssemblyKeyNameAttribute' has been deprecated. Use 'AssemblyKeyFileAttribute' instead. 'AssemblyKeyNameAttribute' a été déprécié. Utilisez 'AssemblyKeyFileAttribute' à la place. Key container signing is not supported on this platform. La signature de conteneurs de clés n'est pas prise en charge sur cette plateforme. Available overloads:\n{0} Surcharges disponibles :\n{0} A generic construct requires that a generic type parameter be known as a struct or reference type. Consider adding a type annotation. L'utilisation d'une construction générique est possible uniquement si un paramètre de type générique est connu en tant que type struct ou type référence. Ajoutez une annotation de type. Known types of arguments: {0} Types d'argument connus : {0} Known type of argument: {0} Type d'argument connu : {0} Known return type: {0} Type de retour connu : {0} Known type parameters: {0} Paramètres de type connus : {0} Known type parameter: {0} Paramètre de type connu : {0} Argument at index {0} doesn't match L'argument à l'index {0} ne correspond pas Argument '{0}' doesn't match L'argument '{0}' ne correspond pas All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n {1} \nThis branch returns a tuple of length {2} of type\n {3} \n Toutes les branches d’une expression « if » doivent retourner des valeurs implicitement convertibles au type de la première branche, qui est ici un tuple de longueur {0} de type\n {1} \nCette branche renvoie un tuple de longueur {2} de type\n {3} \n The type provider designer assembly '{0}' could not be loaded from folder '{1}' because a dependency was missing or could not loaded. All dependencies of the type provider designer assembly must be located in the same folder as that assembly. The exception reported was: {2} - {3} Impossible de charger l'assembly de concepteur de fournisseur de type '{0}' à partir du dossier '{1}', car une dépendance est manquante ou n'a pas pu être chargée. Toutes les dépendances de l'assembly de concepteur de fournisseur de type doivent se trouver dans le même dossier que cet assembly. Exception signalée : {2} - {3} The type provider designer assembly '{0}' could not be loaded from folder '{1}'. The exception reported was: {2} - {3} Impossible de charger l'assembly de concepteur de fournisseur de type '{0}' à partir du dossier '{1}'. Exception signalée : {2} - {3} Assembly attribute '{0}' refers to a designer assembly '{1}' which cannot be loaded or doesn't exist. The exception reported was: {2} - {3} L'attribut d'assembly '{0}' fait référence à un assembly de concepteur '{1}' qui ne peut pas être chargé ou qui n'existe pas. Exception signalée : {2} - {3} additional type-directed conversions conversions supplémentaires dirigées vers le type applicative computation expressions expressions de calcul applicatives Arithmetic and logical operations in literals, enum definitions and attributes Opérations arithmétiques et logiques dans les littéraux, les définitions d'énumération et les attributs attributes to the right of the 'module' keyword attributs à droite du mot clé 'module' automatic generation of 'Message' property for 'exception' declarations génération automatique de la propriété « Message » pour les déclarations « exception » Allow implicit Extension attribute on declaring types, modules Autoriser l’attribut implicite Extension lors de la déclaration des types, modules default interface member consumption consommation par défaut des membres d'interface fix to resolution of delegate type names, see https://github.com/dotnet/fsharp/issues/10228 corriger pour résoudre les noms de types délégués, voir https://github.com/dotnet/fsharp/issues/10228 discard pattern in use binding annuler le modèle dans la liaison d’utilisation dotless float32 literal littéral float32 sans point Raises errors for non-virtual members overrides Déclenche des erreurs pour les remplacements de membres non virtuels give error on deprecated access of construct with RequireQualifiedAccess attribute donner une erreur sur l’accès déconseillé de la construction avec l’attribut RequireQualifiedAccess Error reporting on static classes Rapport d’erreurs sur les classes statiques Escapes curly braces before calling FormattableStringFactory.Create when interpolated string literal is typed as FormattableString Échappe les accolades avant d’appeler FormattableStringFactory.Create lorsque le littéral de chaîne interpolé est tapé en tant que FormattableString. more types support units of measure d'autres types prennent en charge les unités de mesure fixed-index slice 3d/4d section à index fixe 3D/4D from-end slicing découpage depuis la fin implicit yield yield implicite expr[idx] notation for indexing and slicing Notation expr[idx] pour l’indexation et le découpage support for consuming init properties prise en charge de la consommation des propriétés init static abstract interface members membres d’interface abstraite statiques interfaces with multiple generic instantiation interfaces avec plusieurs instanciations génériques Allow lowercase DU when RequireQualifiedAccess attribute Autoriser les DU en minuscules pour l'attribut RequireQualifiedAccess ML compatibility revisions Réviseurs de compatibilité ML Pattern match discard is not allowed for union case that takes no data. L’abandon des correspondances de modèle n’est pas autorisé pour un cas d’union qui n’accepte aucune donnée. nameof nameof Nested record field copy-and-update Copier et mettre à jour un champ d'enregistrement imbriqué String values marked as literals and IL constants as printf format Valeurs de chaîne marquées comme littéraux et constantes IL au format printf non-variable patterns to the right of 'as' patterns modèles non variables à droite de modèles « as » nullable optional interop interopérabilité facultative pouvant accepter une valeur null open type declaration déclaration de type ouverte overloads for custom operations surcharges pour les opérations personnalisées package management Package Management binary formatting for integers mise en forme binaire pour les entiers list literals of any size répertorier les littéraux de n’importe quelle taille informational messages related to reference cells messages d’information liés aux cellules de référence whitespace relexation assouplissement de la mise en retrait avec des espaces blancs whitespace relaxation v2 relaxation des espaces blancs v2 support for required properties prise en charge des propriétés obligatoires resumable state machines ordinateurs d’état pouvant être repris self type constraints contraintes d’auto-type single underscore pattern modèle de trait de soulignement unique Static members in interfaces Membres statiques dans les interfaces string interpolation interpolation de chaîne struct representation for active patterns représentation de structure pour les modèles actifs Support for try-with in sequence expressions Prise en charge de try-with dans les expressions de séquence Raises warnings when an copy-and-update record expression changes all fields of a record. Génère des avertissements lorsqu'une expression d'enregistrement de copie et de mise à jour modifie tous les champs d'un enregistrement. Raises warnings when 'let inline ... =' is used together with [<MethodImpl(MethodImplOptions.NoInlining)>] attribute. Function is not getting inlined. Génère des avertissements lorsque « let inline ... = » est utilisé avec l’attribut [<MethodImpl(MethodImplOptions.NoInlining)>]. La fonction n’est pas inlined. wild card in for loop caractère générique dans une boucle for witness passing for trait constraints in F# quotations Passage de témoin pour les contraintes de trait dans les quotations F# All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is a tuple of length {0} of type\n {1} \nThis branch returns a tuple of length {2} of type\n {3} \n Toutes les branches d’une expression de correspondance de motifs doivent retourner des valeurs implicitement convertibles au type de la première branche, qui est ici un tuple de longueur {0} de type\n {1} \nCette branche renvoie un tuple de longueur {2} de type\n {3} \n Interpolated strings may not use '%' format specifiers unless each is given an expression, e.g. '%d{{1+1}}'. Les chaînes interpolées ne peuvent pas utiliser les spécificateurs de format '%' à moins de recevoir une expression, par exemple '%d{{1+1}}'. .NET-style format specifiers such as '{{x,3}}' or '{{x:N5}}' may not be mixed with '%' format specifiers. Les spécificateurs de format de style .NET tels que '{{x,3}}' et '{{x:N5}}' ne peuvent pas être combinés avec les spécificateurs de format '%'. The '%P' specifier may not be used explicitly. Le spécificateur '%P' ne peut pas être utilisé explicitement. Interpolated strings used as type IFormattable or type FormattableString may not use '%' specifiers, only .NET-style interpolands such as '{{expr}}', '{{expr,3}}' or '{{expr:N5}}' may be used. Les chaînes interpolées utilisées en tant que type IFormattable ou FormattableString ne peuvent pas utiliser les spécificateurs '%'. Seuls les spécificateurs de style .NET tels que '{{expr}}', '{{expr,3}}' et '{{expr:N5}}' peuvent être utilisés. The '%A' format specifier may not be used in an assembly being compiled with option '--reflectionfree'. This construct implicitly uses reflection. Le spécificateur de format '%A' ne peut pas être utilisé dans un assembly compilé avec l’option '--reflectionfree'. Cette construction utilise implicitement la réflexion. - {0} - {0} The 'from the end slicing' feature requires language version 'preview'. La fonctionnalité « from the end slicing » nécessite la version de langage « preview ». Invalid directive '#{0} {1}' Directive non valide '#{0} {1}' The 'if' expression needs to return a tuple of length {0} of type\n {1} \nto satisfy context type requirements. It currently returns a tuple of length {2} of type\n {3} \n L’expression « if » doit retourner un tuple de longueur {0} de type\n {1} \npour répondre aux exigences de type de contexte. Il retourne actuellement un tuple de longueur {2} de type\n {3} \n Unknown debug point '{0}'. The available debug points are '{1}'. Point de débogage inconnu « {0} ». Les points de débogage disponibles sont «{1}». The resumable code construct '{0}' may only be used in inlined code protected by 'if __useResumableCode then ...' and the overall composition must form valid resumable code. La construction de code pouvant être repris «{0}» ne peut être utilisée que dans du code inlined protégé par «if __useResumableCode then ...» et la composition globale doit former un code pouvant être repris valide. The 'InlineIfLambda' attribute is present in the signature but not the implementation. L’attribut « InlineIfLambda » est présent dans la signature, mais pas dans l’implémentation. XML comment is not placed on a valid language element. Le commentaire XML n'est pas placé dans un élément valide du langage. Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters. 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. Keyword to specify a constant literal as a type parameter argument in Type Providers. Mot clé permettant de spécifier une constante littérale en tant qu'argument de paramètre de type dans les fournisseurs de types. Keyword reserved for ML-compatibility. Mot clé réservé à la compatibilité ML. Used to check if an object is of the given type in a pattern or binding. Permet de vérifier si un objet est du type donné dans un modèle ou une liaison. a byte string may not be interpolated une chaîne d'octets ne peut pas être interpolée IF-FSHARP/IF-CAML regions are no longer supported Les régions IF-FSHARP/IF-CAML ne sont plus prises en charge. A '}}' character must be escaped (by doubling) in an interpolated string. Un caractère '}}' doit faire l'objet d'une séquence d'échappement (par doublement) dans une chaîne interpolée. Invalid interpolated string. Single quote or verbatim string literals may not be used in interpolated expressions in single quote or verbatim strings. Consider using an explicit 'let' binding for the interpolation expression or use a triple quote string as the outer string literal. Chaîne interpolée non valide. Les littéraux de chaîne verbatim ou à guillemet simple ne peuvent pas être utilisés dans les expressions interpolées dans des chaînes verbatim ou à guillemet simple. Utilisez une liaison 'let' explicite pour l'expression d'interpolation ou une chaîne à guillemets triples comme littéral de chaîne externe. Invalid interpolated string. Triple quote string literals may not be used in interpolated expressions. Consider using an explicit 'let' binding for the interpolation expression. Chaîne interpolée non valide. Les littéraux de chaîne à guillemets triples ne peuvent pas être utilisés dans des expressions interpolées. Utilisez une liaison 'let' explicite pour l'expression d'interpolation. All elements of a list must be implicitly convertible to the type of the first element, which here is a tuple of length {0} of type\n {1} \nThis element is a tuple of length {2} of type\n {3} \n Tous les éléments d’une liste doivent être implicitement convertibles en type du premier élément, qui est ici un tuple de longueur {0} de type\n {1} \nCet élément est un tuple de longueur {2} de type\n {3} \n Pattern discard is not allowed for union case that takes no data. L’abandon de modèle n’est pas autorisé pour un cas d’union qui n’accepte aucune donnée. This construct is deprecated. {0}. You can enable this feature by using '--langversion:5.0' and '--mlcompatibility'. Cette construction est déconseillée. {0}. Vous pouvez activer cette fonctionnalité à l’aide de'--langversion : 5.0 'et'--mlcompatibility'. In previous versions of F# '{0}' was a reserved keyword but the use of this keyword is now deprecated Dans les versions précédentes de F # ' {0} 'était un mot clé réservé mais l’utilisation de ce mot clé est désormais déconseillée. The use of '#light \"off\"' or '#indent \"off\"' was deprecated in F# 2.0 and is no longer supported L’utilisation de' #light \ "OFF \" ou' #indent \ "OFF \" a été dépréciée dans F # 2,0 et n’est plus prise en charge The use of multiple parenthesized type parameters before a generic type name such as '(int, int) Map' was deprecated in F# 2.0 and is no longer supported L’utilisation de plusieurs paramètres de type entre parenthèses avant un nom de type générique, tel que' (int, int) map', a été dépréciée dans F # 2,0 et n’est plus prise en charge. The use of 'module M: sig ... end ' was deprecated in F# 2.0 and is no longer supported. Change the ':' to an '=' and remove the 'sig' and 'end' and use indentation instead L’utilisation de ’module M : SIG... end’a été déconseillé dans F # 2,0 et n’est plus pris en charge. Remplacer « : » par « = » et supprimer les éléments « SIG » et « end », et utiliser la mise en retrait à la place. The use of 'module M = sig ... end ' was deprecated in F# 2.0 and is no longer supported. Remove the 'sig' and 'end' and use indentation instead L'utilisation de 'module M = sig ... end ' a été dépréciée dans F# 2.0 et n'est plus supportée. Supprimez les termes « sig » et « end » et utilisez l'indentation à la place. The use of 'module M = struct ... end ' was deprecated in F# 2.0 and is no longer supported. Remove the 'struct' and 'end' and use indentation instead L'utilisation de 'module M = struct ... end ' a été dépréciée dans F# 2.0 et n'est plus supportée. Supprimez les termes « struct » et « end » et utilisez l'indentation à la place. Stream does not begin with a null resource and is not in '.RES' format. Le flux ne commence pas par une ressource null et n'est pas au format '.RES'. Resource header beginning at offset {0} is malformed. L'en-tête de ressource commençant au décalage {0} est mal formé. This expression is not a function and cannot be applied. Did you intend to access the indexer via 'expr[index]'? Cette expression n'est pas une fonction et ne peut pas être appliquée. Souhaitiez-vous accéder à l'indexeur via « expr[index] »? This value is not a function and cannot be applied. Did you intend to access the indexer via '{0}[index]'? Cette valeur n'est pas une fonction et ne peut pas être appliquée. Souhaitiez-vous accéder à l'indexeur via « {0}[index] » ? The value '{0}' was marked 'InlineIfLambda' but was not determined to have a lambda value. This warning is for informational purposes only. La valeur «{0} » a été marquée comme « InlineIfLambda », mais elle n’a pas été déterminée comme ayant une valeur lambda. Cet avertissement est à titre d’information uniquement. Print the inferred interfaces of all compilation files to associated signature files Imprimer les interfaces inférées de tous les fichiers de compilation sur les fichiers de signature associés Clear the package manager results cache Effacer le cache des résultats du Gestionnaire de package Compress interface and optimization data files Compresser les fichiers de données d’interface et d’optimisation Display the allowed values for language version. Affichez les valeurs autorisées pour la version du langage. Invalid use of emitting a reference assembly, do not use '--standalone or --staticlink' with '--refonly or --refout'. Utilisation non valide de l’émission d’un assembly de référence, n’utilisez pas '--standalone ou --staticlink' avec '--refonly ou --refout'. Invalid reference assembly path' Chemin d'assemblage de référence non valide' Specify included optimization information, the default is file. Important for distributed libraries. Spécifiez les informations d’optimisation incluses, la valeur par défaut est le fichier. Important pour les bibliothèques distribuées. The pdb output file name cannot match the build output filename use --pdb:filename.pdb Le nom du fichier de sortie pdb ne peut pas correspondre au nom de fichier de sortie de build utilisé --pdb:filename.pdb. Produce a reference assembly, instead of a full assembly, as the primary output Produire un assembly de référence, au lieu d’un assembly complet, en tant que sortie principale Produce a reference assembly with the specified file path. Produire un assembly de référence avec le chemin de fichier spécifié Disable implicit generation of constructs using reflection Désactiver la génération implicite de constructions à l’aide de la réflexion Specify language version such as 'latest' or 'preview'. Spécifiez une version de langage telle que 'latest' ou 'preview'. Include F# interface information, the default is file. Essential for distributing libraries. Incluez les informations de l’interface F#, la valeur par défaut est un fichier. Essentiel pour la distribution des bibliothèques. Supported language versions: Versions linguistiques prises en charge : Invalid value '{0}' for --optimizationdata, valid value are: none, file, compress. Valeur non valide '{0}' pour --optimizationdata. Les valeurs valides sont : none, file, compress. Invalid value '{0}' for --interfacedata, valid value are: none, file, compress. Valeur non valide '{0}' pour --interfacedata. Les valeurs valides sont : none, file, compress. Unrecognized value '{0}' for --langversion use --langversion:? for complete list Valeur non reconnue '{0}' pour --langversion use --langversion:? pour la liste complète Display compiler version banner and exit Afficher la bannière de la version du compilateur et quitter Specify a Win32 icon file (.ico) Spécifier un fichier icône (.ico) Win32 The 'package management' feature requires language version 5.0 or above La fonction « gestion des paquets » nécessite une version de langue 5.0 ou supérieure. Invalid interpolated string. This interpolated string expression fill is empty, an expression was expected. Chaîne interpolée non valide. Le remplissage de cette expression de chaîne interpolée est vide. Une expression est attendue. Incomplete interpolated string begun at or before here Chaîne interpolée incomplète ayant débuté à cet emplacement ou avant Incomplete interpolated string expression fill begun at or before here Remplissage d'expression de chaîne interpolée incomplet ayant débuté à cet emplacement ou avant Incomplete interpolated triple-quote string begun at or before here Chaîne à guillemets triples interpolée incomplète ayant débuté à cet emplacement ou avant Incomplete interpolated verbatim string begun at or before here Chaîne verbatim interpolée incomplète ayant débuté à cet emplacement ou avant Unexpected token in type definition. Expected '=' after the type '{0}'. Jeton inattendu dans la définition de type. Signe '=' attendu après le type '{0}'. Expected a pattern after this point Modèle attendu après ce point Expecting expression Expression attendue Expecting pattern Modèle attendu Incomplete character literal (example: 'Q') or qualified type invocation (example: 'T.Name) Littéral de caractère incomplet (exemple : 'Q') ou appel de type qualifié (exemple : 'T.Name) Incomplete operator expression (example a^b) or qualified type invocation (example: ^T.Name) Expression d’opérateur incomplète (exemple a^b) ou appel de type qualifié (exemple : ^T.Name) This member access is ambiguous. Please use parentheses around the object creation, e.g. '(new SomeType(args)).MemberName' L’accès à ce membre est ambigu. Utilisez des parenthèses autour de la création de l’objet, par exemple' (New SomeType (args)). MemberName Unexpected end of input in 'else if' or 'elif' branch of conditional expression. Expected 'elif <expr> then <expr>' or 'else if <expr> then <expr>'. Fin d'entrée inattendue dans la branche 'else if' ou 'elif' de l'expression conditionnelle. Attendu 'elif <expr> then <expr>' ou 'else if <expr> then <expr>'. Unexpected symbol '.' in member definition. Expected 'with', '=' or other token. Symbole '.' inattendu dans la définition du membre. 'with','=' ou autre jeton attendu. Specify algorithm for calculating source file checksum stored in PDB. Supported values are: SHA1 or SHA256 (default) Spécifiez l'algorithme pour calculer la somme de contrôle du fichier source stocké au format PDB. Les valeurs prises en charge sont : SHA1 ou SHA256 (par défaut) Algorithm '{0}' is not supported Algorithme '{0}' non pris en charge A constrained generic construct occured in the resumable code specification Une construction générique contrainte s'est produite dans la spécification de code de reprise A target label for __resumeAt was not statically determined. A __resumeAt with a non-static target label may only appear at the start of a resumable code method Une étiquette cible pour __resumeAt n’a pas été déterminée de manière statique. Un __resumeAt avec une étiquette cible non statique ne peut apparaître qu’au début d’une méthode de code repris A fast integer for loop may not contain resumption points Un entier rapide pour la boucle peut ne pas contenir de points de reprise A 'let rec' occured in the resumable code specification Un «let rec» s’est produit dans la spécification de code pouvant être repris The 'with' block of a try/with may not contain resumption points Le bloc « with » d’un bloc try/with ne peut pas contenir de points de reprise A try/finally may not contain resumption points Un try/finally peut ne pas contenir de points de reprise A delegate or function producing resumable code in a state machine has type parameters Un délégué ou une fonction produisant du code pouvant être reprise dans un ordinateur d’état a des paramètres de type A resumable code invocation at '{0}' could not be reduced Un appel de code pouvant être repris à «{0}» n’a pas pu être réduit The resumable code value(s) '{0}' does not have a definition La ou les valeurs de code pouvant être repris «{0}» n’ont pas de définition #i is not supported by the registered PackageManagers #i n'est pas pris en charge par les PackageManagers inscrits The state machine has an unexpected form La machine d’état présente une forme inattendue This state machine is not statically compilable. {0}. An alternative dynamic implementation will be used, which may be slower. Consider adjusting your code to ensure this state machine is statically compilable, or else suppress this warning. Cet ordinateur d’état n’est pas compilable statiquement. {0}. Une autre implémentation dynamique sera utilisée, ce qui peut être plus lent. Envisagez d’ajuster votre code pour vous assurer que cet ordinateur d’état est compilable statiquement, ou supprimez cet avertissement. This state machine is not statically compilable and no alternative is available. {0}. Use an 'if __useResumableCode then <state-machine> else <alternative>' to give an alternative. Cet ordinateur d’état n’est pas compilable statiquement et aucune alternative n’est disponible. {0}. Utilisez un «if __useResumableCode puis <state-machine>else <alternative>» pour donner une alternative. The .NET SDK for this script could not be determined. If the script is in a directory using a 'global.json' then ensure the relevant .NET SDK is installed. The output from '{0} --version' in the directory '{1}' was: '{2}' and the exit code was '{3}'. Le kit SDK .NET de ce script n'a pas pu être déterminé. Si le script se trouve dans un répertoire utilisant un fichier 'global.json', vérifiez que le kit SDK .NET approprié est installé. La sortie de '{0} --version' dans le répertoire '{1}' était '{2}', et le code de sortie était '{3}'. The .NET SDK for this script could not be determined. dotnet.exe could not be found ensure a .NET SDK is installed. Impossible de déterminer le Kit de développement logiciel (SDK) .NET pour ce script. dotnet.exe est introuvable pour garantir l’installation d’un kit SDK .NET. The .NET SDK for this script could not be determined. If the script is in a directory using a 'global.json' then ensure the relevant .NET SDK is installed. Unexpected error '{0}'. Le kit SDK .NET de ce script n'a pas pu être déterminé. Si le script se trouve dans un répertoire utilisant un fichier 'global.json', vérifiez que le kit SDK .NET approprié est installé. Erreur inattendue '{0}'. This expression has type '{0}' and is only made compatible with type '{1}' through an ambiguous implicit conversion. Consider using an explicit call to 'op_Implicit'. The applicable implicit conversions are:{2} Cette expression a le type « {0} » et est uniquement compatible avec le type « {1} » via une conversion implicite ambiguë. Envisagez d’utiliser un appel explicite à’op_Implicit'. Les conversions implicites applicables sont : {2} This feature is not supported in this version of F#. You may need to add /langversion:preview to use this feature. Cette fonctionnalité n'est pas prise en charge dans cette version de F#. Vous devrez peut-être ajouter /langversion:preview pour pouvoir utiliser cette fonctionnalité. The field '{0}' appears multiple times in this record expression. Le champ «{0}» apparaît plusieurs fois dans cette expression d’enregistrement. This is the wrong anonymous record. It should have the fields {0}. Il s'agit de l'enregistrement anonyme incorrect. Il doit contenir les champs {0}. This anonymous record does not have enough fields. Add the missing fields {0}. Cet enregistrement anonyme ne contient pas suffisamment de champs. Ajoutez les champs manquants {0}. This anonymous record has too many fields. Remove the extra fields {0}. Cet enregistrement anonyme a trop de champs. Supprimez les champs supplémentaires {0}. Invalid Anonymous Record type declaration. Déclaration de type d'enregistrement anonyme non valide. The field '{0}' appears multiple times in this anonymous record type. Le champ '{0}' apparaît plusieurs fois dans ce type d'enregistrement anonyme. Attributes cannot be applied to type extensions. Impossible d'appliquer des attributs aux extensions de type. This copy-and-update record expression changes all fields of record type '{0}'. Consider using the record construction syntax instead. Cette expression d'enregistrement de copie et de mise à jour modifie tous les champs du type d'enregistrement '{0}'. Envisagez d'utiliser la syntaxe de construction d'enregistrement à la place. The syntax 'expr1[expr2]' is used for indexing. Consider adding a type annotation to enable indexing, or if calling a function add a space, e.g. 'expr1 [expr2]'. La syntaxe « expr1[expr2] » est utilisée pour l’indexation. Envisagez d’ajouter une annotation de type pour activer l’indexation, ou si vous appelez une fonction, ajoutez un espace, par exemple « expr1 [expr2] ». The syntax 'expr1[expr2]' is now reserved for indexing. See https://aka.ms/fsharp-index-notation. If calling a function, add a space between the function and argument, e.g. 'someFunction [expr]'. La syntaxe « expr1[expr2] » est désormais réservée à l’indexation. Voir https://aka.ms/fsharp-index-notation. Si vous appelez une fonction, ajoutez un espace entre la fonction et l’argument, par exemple « someFunction [expr] ». Byref types are not allowed in an open type declaration. Les types Byref ne sont pas autorisés dans une déclaration de type ouverte. The syntax 'arr.[idx]' is now revised to 'arr[idx]'. Please update your code. La syntaxe « arr.[idx] » est maintenant remplacée par « arr[idx] ». Veuillez mettre à jour votre code. This expression uses a built-in implicit conversion to convert type '{0}' to type '{1}'. See https://aka.ms/fsharp-implicit-convs. Cette expression utilise une conversion implicite intégrée pour convertir le type « {0} » en type « {1} ». Voir https://aka.ms/fsharp-implicit-convs. This expression uses the implicit conversion '{0}' to convert type '{1}' to type '{2}'. Cette expression utilise la conversion implicite « {0} » pour convertir le type « {1} » en type « {2} ». This expression uses the implicit conversion '{0}' to convert type '{1}' to type '{2}'. See https://aka.ms/fsharp-implicit-convs. This warning may be disabled using '#nowarn \"3391\". Cette expression utilise la conversion implicite '{0}' pour convertir le type '{1}' en type '{2}'. Voir https://aka.ms/fsharp-implicit-convs. Cet avertissement peut être désactivé en utilisant '#nowarn \"3391\". Init-only property '{0}' cannot be set outside the initialization code. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization La propriété init-only '{0}' ne peut pas être définie en dehors du code d’initialisation. Voir https://aka.ms/fsharp-assigning-values-to-properties-at-initialization The 'InlineIfLambda' attribute may only be used on parameters of inlined functions of methods whose type is a function or F# delegate type. L’attribut « InlineIfLambda » ne peut être utilisé que sur les paramètres des fonctions incorporées des méthodes dont le type est une fonction ou un type délégué F#. Mismatch in interpolated string. Interpolated strings may not use '%' format specifiers unless each is given an expression, e.g. '%d{{1+1}}' Incompatibilité dans la chaîne interpolée. Les chaînes interpolées ne peuvent pas utiliser les spécificateurs de format '%' à moins de recevoir une expression, par exemple '%d{{1+1}}' Invalid alignment in interpolated string Alignement non valide dans la chaîne interpolée Invalid member declaration. The name of the member is missing or has parentheses. Déclaration de membre non valide. Le nom du membre est manquant ou comporte des parenthèses. The construct '{0}' may only be used in valid resumable code. La construction «{0}» ne peut être utilisée que dans un code pouvant être repris valide. Invalid constraint. Valid constraint forms include \"'T :> ISomeInterface\" for interface constraints and \"SomeConstrainingType<'T>\" for self-constraints. See https://aka.ms/fsharp-type-constraints. Contrainte non valide. Les formes de contrainte valides incluent \"'T :> ISomeInterface\" pour les contraintes d’interface et \"SomeConstrainingType<'T>\" pour les contraintes automatiques. Consultez https://aka.ms/fsharp-type-constraints. The use of '[<Struct>]' on values, functions and methods is only allowed on partial active pattern definitions L’utilisation de' [<Struct>] 'sur les valeurs, les fonctions et les méthodes n’est autorisée que sur les définitions de modèle actif partiel use! may not be combined with and! use! ne peut pas être combiné avec and! Invalid use of reverse index in list expression. Utilisation non valide de l’index inverse dans l’expression de liste. The syntax '[expr1][expr2]' is ambiguous when used as an argument. See https://aka.ms/fsharp-index-notation. If you intend indexing or slicing then you must use '(expr1).[expr2]' in argument position. If calling a function with multiple curried arguments, add a space between them, e.g. 'someFunction [expr1] [expr2]'. La syntaxe « [expr1][expr2] » est ambiguë lorsqu’elle est utilisée comme argument. Voir https://aka.ms/fsharp-index-notation. Si vous avez l’intention d’indexer ou de découper, vous devez utiliser « (expr1).[expr2] » en position d’argument. Si vous appelez une fonction avec plusieurs arguments codés, ajoutez un espace entre eux, par exemple « someFunction [expr1] [expr2] ». The syntax '[expr1][expr2]' is now reserved for indexing and is ambiguous when used as an argument. See https://aka.ms/fsharp-index-notation. If calling a function with multiple curried arguments, add a space between them, e.g. 'someFunction [expr1] [expr2]'. La syntaxe « [expr1][expr2] » est désormais réservée à l’indexation et est ambiguë lorsqu’elle est utilisée comme argument. Voir https://aka.ms/fsharp-index-notation. Si vous appelez une fonction avec plusieurs arguments codés, ajoutez un espace entre eux, par exemple « someFunction [expr1] [expr2] ». A [<Literal>] declaration cannot use an active pattern for its identifier Une déclaration [<Literal>] ne peut pas utiliser un modèle actif en tant qu'identificateur Cannot assign a value to another value marked literal Impossible d'affecter une valeur à une autre valeur marquée comme littérale Cannot assign '{0}' to a value marked literal Impossible d'affecter '{0}' à une valeur marquée comme littérale The following required properties have to be initalized:{0} Les propriétés requises suivantes doivent être initialisées :{0} Using methods with 'NoEagerConstraintApplicationAttribute' requires /langversion:6.0 or later L’utilisation de méthodes avec « NoEagerConstraintApplicationAttribute » requiert/langversion:6.0 ou ultérieur This expression supports indexing, e.g. 'expr.[index]'. The syntax 'expr[index]' requires /langversion:preview. See https://aka.ms/fsharp-index-notation. Cette expression prend en charge l’indexation, par exemple « expr.[index] ». La syntaxe « expr[index] » requiert /langversion:preview. Voir https://aka.ms/fsharp-index-notation. This value supports indexing, e.g. '{0}.[index]'. The syntax '{1}[index]' requires /langversion:preview. See https://aka.ms/fsharp-index-notation. Cette valeur prend en charge l’indexation, par exemple « {0}.[index] ». La syntaxe « {1}[index] » nécessite /langversion:preview. Voir https://aka.ms/fsharp-index-notation. This expression is not a function and does not support index notation. Cette expression n’est pas une fonction et ne prend pas en charge la notation d’index. The value '{0}' is not a function and does not support index notation. La valeur « {0} » n’est pas une fonction et ne prend pas en charge la notation d’index. The syntax 'expr1[expr2]' is ambiguous when used as an argument. See https://aka.ms/fsharp-index-notation. If you intend indexing or slicing then you must use 'expr1.[expr2]' in argument position. If calling a function with multiple curried arguments, add a space between them, e.g. 'someFunction expr1 [expr2]'. La syntaxe « expr1[expr2] » est ambiguë lorsqu’elle est utilisée comme argument. Voir https://aka.ms/fsharp-index-notation. Si vous avez l’intention d’indexer ou de découper, vous devez utiliser « expr1.[expr2] » en position d’argument. Si vous appelez une fonction avec plusieurs arguments codés, ajoutez un espace entre eux, par exemple « someFunction expr1 [expr2] ». The syntax 'expr1[expr2]' is now reserved for indexing and is ambiguous when used as an argument. See https://aka.ms/fsharp-index-notation. If calling a function with multiple curried arguments, add a space between them, e.g. 'someFunction expr1 [expr2]'. La syntaxe « expr1[expr2] » est désormais réservée à l’indexation et est ambiguë lorsqu’elle est utilisée comme argument. Voir https://aka.ms/fsharp-index-notation. Si vous appelez une fonction avec plusieurs arguments codés, ajoutez un espace entre eux, par exemple « someFunction expr1 [expr2] ». The syntax '(expr1)[expr2]' is ambiguous when used as an argument. See https://aka.ms/fsharp-index-notation. If you intend indexing or slicing then you must use '(expr1).[expr2]' in argument position. If calling a function with multiple curried arguments, add a space between them, e.g. 'someFunction (expr1) [expr2]'. La syntaxe « (expr1)[expr2] » est ambiguë lorsqu’elle est utilisée comme argument. Voir https://aka.ms/fsharp-index-notation. Si vous avez l’intention d’indexer ou de découper, vous devez utiliser « (expr1).[expr2] » en position d’argument. Si vous appelez une fonction avec plusieurs arguments codés, ajoutez un espace entre eux, par exemple « someFunction (expr1) [expr2] ». The syntax '(expr1)[expr2]' is now reserved for indexing and is ambiguous when used as an argument. See https://aka.ms/fsharp-index-notation. If calling a function with multiple curried arguments, add a space between them, e.g. 'someFunction (expr1) [expr2]'. La syntaxe « (expr1)[expr2] » est désormais réservée à l’indexation et est ambiguë lorsqu’elle est utilisée comme argument. Voir https://aka.ms/fsharp-index-notation. Si vous appelez une fonction avec plusieurs arguments codés, ajoutez un espace entre eux, par exemple « someFunction (expr1) [expr2] ». The 'let! ... and! ...' construct may only be used if the computation expression builder defines either a '{0}' method or appropriate 'MergeSource' and 'Bind' methods La construction 'let! ... and! ...' peut uniquement être utilisée si le générateur d'expressions de calcul définit une méthode '{0}' ou les méthodes 'MergeSource' et 'Bind' appropriées Invalid resumable code. A resumable code parameter must be of delegate or function type Code pouvant être repris non valide. Un paramètre de code pouvant être repris doit être de type délégué ou de fonction Invalid resumable code. Resumable code parameter must have name beginning with '__expand' Code pouvant être reprise non valide. Le paramètre de code pouvant être repris doit avoir un nom commençant par « __expand » Invalid resumable code. A 'let rec' occured in the resumable code specification Code pouvant être reprise non valide. Un «let rec» s’est produit dans la spécification de code pouvant être repris Invalid resumable code. Any method of function accepting or returning resumable code must be marked 'inline' Code pouvant être repris non valide. Toute méthode de fonction acceptant ou retournant du code pouvant être repris doit être marquée «inline» Resumable code invocation. Suppress this warning if you are defining new low-level resumable code in terms of existing resumable code. Appel de code pouvant être repris. Supprimez cet avertissement si vous définissez un nouveau code pouvant être repris de bas niveau en termes de code pouvant être repris existant. Using resumable code or resumable state machines requires /langversion:preview L’utilisation de code pouvant être repris ou de machines d’état pouvant être reprises nécessite /langversion:preview Cannot call '{0}' - a setter for init-only property, please use object initialization instead. See https://aka.ms/fsharp-assigning-values-to-properties-at-initialization Nous n’avons pas pu appeler '{0}' - méthode setter pour la propriété init-only. Utilisez plutôt l’initialisation d’objet. Consultez https://aka.ms/fsharp-assigning-values-to-properties-at-initialization. This expression implicitly converts type '{0}' to type '{1}'. See https://aka.ms/fsharp-implicit-convs. Cette expression convertit implicitement le type « {0} » en type « {1} ». Voir https://aka.ms/fsharp-implicit-convs. SynType.Or is not permitted in this declaration SynType.Or n’est pas autorisé dans cette déclaration The trait '{0}' invoked by this call has multiple support types. This invocation syntax is not permitted for such traits. See https://aka.ms/fsharp-srtp for guidance. La caractéristique '{0}' invoquée par cet appel a plusieurs types de prise en charge. Cette syntaxe d’appel n’est pas autorisée pour de telles caractéristiques. Consultez https://aka.ms/fsharp-srtp pour obtenir de l’aide. Invocation of a static constraint should use \"'T.Ident\" and not \"^T.Ident\", even for statically resolved type parameters. L’appel d’une contrainte statique doit utiliser \"'T.Ident\" et non \"^T.Ident\", même pour les paramètres de type résolus statiquement. Trait '{0}' is not static Le '{0}' de caractéristique n’est pas statique. Trait '{0}' is static Le '{0}' de caractéristique est statique. A trait may not specify optional, in, out, ParamArray, CallerInfo or Quote arguments Une caractéristique ne peut pas spécifier d’arguments facultatifs, in, out, ParamArray, CallerInfo ou Quote Invalid interpolated string. {0} Chaîne interpolée non valide. {0} '{0}' is normally used as a type constraint in generic code, e.g. \"'T when ISomeInterface<'T>\" or \"let f (x: #ISomeInterface<_>)\". See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3536\"' or '--nowarn:3536'. '{0}' est généralement utilisée comme contrainte de type dans le code générique, par exemple \"'T when ISomeInterface<'T>\" or \"let f (x: #ISomeInterface<_>)\". Consultez https://aka.ms/fsharp-iwsams pour obtenir de l’aide. Vous pouvez désactiver cet avertissement à l’aide de '#nowarn \"3536\"' or '--nowarn:3536'. Declaring \"interfaces with static abstract methods\" is an advanced feature. See https://aka.ms/fsharp-iwsams for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'. La déclaration de \"interfaces with static abstract methods\" est une fonctionnalité avancée. Consultez https://aka.ms/fsharp-iwsams pour obtenir de l’aide. Vous pouvez désactiver cet avertissement à l’aide de '#nowarn \"3535\"' or '--nowarn:3535'. Interface member '{0}' does not have a most specific implementation. Le membre d'interface '{0}' n'a pas l'implémentation la plus spécifique. '{0}' cannot implement the interface '{1}' with the two instantiations '{2}' and '{3}' because they may unify. '{0}' ne peut pas implémenter l'interface '{1}' avec les deux instanciations '{2}' et '{3}', car elles peuvent s'unifier. You cannot implement the interface '{0}' with the two instantiations '{1}' and '{2}' because they may unify. Vous ne pouvez pas implémenter l'interface '{0}' avec les deux instanciations '{1}' et '{2}', car elles peuvent s'unifier. A type has been implicitly inferred as 'obj', which may be unintended. Consider adding explicit type annotations. You can disable this warning by using '#nowarn \"3559\"' or '--nowarn:3559'. Un type a été implicitement déduit comme 'obj', ce qui peut être involontaire. Envisagez d'ajouter des annotations de type explicites. Vous pouvez désactiver cet avertissement en utilisant '#nowarn \"3559\"' ou '--nowarn:3559'. The type '{0}' does not define the field, constructor or member '{1}'. Le type '{0}' ne définit pas le champ, le constructeur ou le membre '{1}'. The namespace '{0}' is not defined. L'espace de noms '{0}' n'est pas défini. The namespace or module '{0}' is not defined. L'espace de noms ou le module '{0}' n'est pas défini. The field, constructor or member '{0}' is not defined. Le champ, le constructeur ou le membre '{0}' n'est pas défini. The value, constructor, namespace or type '{0}' is not defined. La valeur, le constructeur, l'espace de noms ou le type '{0}' n'est pas défini. The value or constructor '{0}' is not defined. La valeur ou le constructeur '{0}' n'est pas défini. The value, namespace, type or module '{0}' is not defined. La valeur, l'espace de noms, le type ou le module '{0}' n'est pas défini. The constructor, module or namespace '{0}' is not defined. Le constructeur, le module ou l'espace de noms '{0}' n'est pas défini. The type '{0}' is not defined. Le type '{0}' n'est pas défini. The type '{0}' is not defined in '{1}'. Le type '{0}' n'est pas défini dans '{1}'. The record label or namespace '{0}' is not defined. L'étiquette d'enregistrement ou l'espace de noms '{0}' n'est pas défini. The record label '{0}' is not defined. L'étiquette d'enregistrement '{0}' n'est pas définie. Maybe you want one of the following: Peut-être souhaitez-vous l'une des options suivantes : The type parameter {0} is not defined. Le paramètre de type '{0}' n'est pas défini. The pattern discriminator '{0}' is not defined. Le discriminateur de modèle '{0}' n'est pas défini. Replace with '{0}' Remplacer par '{0}' Add . for indexer access. Ajoutez un . pour l'accès à l'indexeur. All elements of a list must be implicitly convertible to the type of the first element, which here is '{0}'. This element has type '{1}'. Tous les éléments d'une liste doivent être implicitement convertibles dans le type du premier élément, qui est ici '{0}'. Cet élément a le type '{1}'. All elements of an array must be implicitly convertible to the type of the first element, which here is '{0}'. This element has type '{1}'. Tous les éléments d'un tableau doivent être implicitement convertibles dans le type du premier élément, qui est ici '{0}'. Cet élément a le type '{1}'. This 'if' expression is missing an 'else' branch. Because 'if' is an expression, and not a statement, add an 'else' branch which also returns a value of type '{0}'. Il manque à l'expression 'if' une branche 'else'. La branche 'then' a le type '{0}'. Dans la mesure où 'if' est une expression, et non une instruction, ajoutez une branche 'else' qui retourne une valeur du même type. The 'if' expression needs to have type '{0}' to satisfy context type requirements. It currently has type '{1}'. L'expression 'if' doit avoir le type '{0}' pour répondre aux exigences de type du contexte. Elle a le type '{1}'. All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is '{0}'. This branch returns a value of type '{1}'. Toutes les branches d'une expression 'if' doivent retourner des valeurs implicitement convertibles au type de la première branche, qui est ici '{0}'. Cette branche renvoie une valeur de type '{1}'. All branches of a pattern match expression must return values implicitly convertible to the type of the first branch, which here is '{0}'. This branch returns a value of type '{1}'. Toutes les branches d'une expression de correspondance de modèle doivent retourner des valeurs implicitement convertibles au type de la première branche, qui est ici '{0}'. Cette branche renvoie une valeur de type '{1}'. A pattern match guard must be of type 'bool', but this 'when' expression is of type '{0}'. Une protection de critères spéciaux doit être de type 'bool', mais cette expression 'when' est de type '{0}'. A ';' is used to separate field values in records. Consider replacing ',' with ';'. Un ';' sert à séparer les valeurs de champs des enregistrements. Remplacez ',' par ';'. The '!' operator is used to dereference a ref cell. Consider using 'not expr' here. L'opérateur '!' est utilisé pour déréférencer une cellule ref. Songez à utiliser 'not expr' ici. The non-generic type '{0}' does not expect any type arguments, but here is given {1} type argument(s) Le type non générique '{0}' n'attend aucun argument de type mais reçoit ici {1} argument(s) de type Consider using 'return!' instead of 'return'. Utilisez 'return!' à la place de 'return'. This attribute is currently unsupported by the F# compiler. Applying it will not achieve its intended effect. Cet attribut n’est actuellement pas pris en charge par le compilateur F #. L’application de celui-ci n’obtiendra pas l’effet souhaité. Use reference assemblies for .NET framework references when available (Enabled by default). Utilisez des assemblys de référence pour les références .NET Framework quand ils sont disponibles (activé par défaut). This XML comment is invalid: '{0}' Ce commentaire XML est non valide : '{0}' This XML comment is invalid: multiple documentation entries for parameter '{0}' Ce commentaire XML est non valide : il existe plusieurs entrées de documentation pour le paramètre '{0}' This XML comment is invalid: unknown parameter '{0}' Ce commentaire XML est non valide : paramètre inconnu '{0}' This XML comment is invalid: missing 'cref' attribute for cross-reference Ce commentaire XML est non valide : attribut 'cref' manquant pour la référence croisée This XML comment is incomplete: no documentation for parameter '{0}' Ce commentaire XML est incomplet : il n'existe aucune documentation pour le paramètre '{0}' This XML comment is invalid: missing 'name' attribute for parameter or parameter reference Ce commentaire XML est non valide : attribut 'name' manquant pour le paramètre ou la référence de paramètre This XML comment is invalid: unresolved cross-reference '{0}' Ce commentaire XML est non valide : référence croisée non résolue '{0}' Consider using 'yield!' instead of 'yield'. Utilisez 'yield!' à la place de 'yield'. \nA tuple type is required for one or more arguments. Consider wrapping the given arguments in additional parentheses or review the definition of the interface. \nUn type de tuple est nécessaire pour un ou plusieurs arguments. Mettez des parenthèses supplémentaires autour des arguments fournis, ou passez en revue la définition de l'interface. Invalid warning number '{0}' Numéro d'avertissement non valide '{0}' Invalid version string '{0}' Chaîne de version non valide '{0}' Invalid version file '{0}' Fichier de version non valide '{0}' Problem with filename '{0}': {1} Problème avec le nom de fichier '{0}' : {1} No inputs specified Absence d'entrée spécifiée The '--pdb' option requires the '--debug' option to be used L'option '--pdb' requiert l'utilisation de l'option '--debug' The search directory '{0}' is invalid Le répertoire de recherche '{0}' n'est pas valide The search directory '{0}' could not be found Le répertoire de recherche '{0}' est introuvable '{0}' is not a valid filename '{0}' n'est pas un nom de fichier valide '{0}' is not a valid assembly name '{0}' n'est pas un nom d'assembly valide Unrecognized privacy setting '{0}' for managed resource, valid options are 'public' and 'private' Paramètre de confidentialité '{0}' non reconnu pour la ressource managée, les options valides sont 'public' et 'private' Unable to read assembly '{0}' Impossible de lire l'assembly '{0}' Assembly resolution failure at or near this location Échec de la résolution de l'assembly à cet emplacement ou à proximité The declarations in this file will be placed in an implicit module '{0}' based on the file name '{1}'. However this is not a valid F# identifier, so the contents will not be accessible from other files. Consider renaming the file or adding a 'module' or 'namespace' declaration at the top of the file. Les déclarations de ce fichier vont être placées dans un module implicite '{0}' en fonction du nom de fichier '{1}'. Toutefois, il ne s'agit pas d'un identificateur F# valide ; par conséquent, le contenu ne sera pas accessible à partir des autres fichiers. Renommez le fichier ou ajoutez une déclaration 'module' ou 'namespace' en haut du fichier. Files in libraries or multiple-file applications must begin with a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule'. Only the last source file of an application may omit such a declaration. Les fichiers situés dans les bibliothèques ou les applications contenant plusieurs fichiers doivent commencer par une déclaration d'espace de noms ou de module, par exemple 'namespace SomeNamespace.SubNamespace' ou 'module SomeNamespace.SomeModule'. Seul le dernier fichier source d'une application peut omettre une telle déclaration. Files in libraries or multiple-file applications must begin with a namespace or module declaration. When using a module declaration at the start of a file the '=' sign is not allowed. If this is a top-level module, consider removing the = to resolve this error. Les fichiers situés dans les bibliothèques ou les applications contenant plusieurs fichiers doivent commencer par une déclaration d'espace de noms ou de module. Quand vous utilisez une déclaration de module au début d'un fichier, le signe '=' n'est pas autorisé. S'il s'agit d'un module de niveau supérieur, supprimez le signe = pour résoudre l'erreur. This file contains multiple declarations of the form 'module SomeNamespace.SomeModule'. Only one declaration of this form is permitted in a file. Change your file to use an initial namespace declaration and/or use 'module ModuleName = ...' to define your modules. Ce fichier contient plusieurs déclarations ayant la forme 'module SomeNamespace.SomeModule'. Seule une déclaration de cette forme est autorisée dans un fichier. Modifiez votre fichier pour utiliser une déclaration d'espace de noms initiale et/ou utilisez 'module ModuleName = ...' pour définir vos modules. Option requires parameter: {0} L'option requiert un paramètre : {0} Source file '{0}' could not be found Le fichier source '{0}' est introuvable The file extension of '{0}' is not recognized. Source files must have extension .fs, .fsi, .fsx, .fsscript, .ml or .mli. L'extension de fichier de '{0}' n'est pas reconnue. Les fichiers sources doivent avoir l'extension .fs, .fsi, .fsx, .fsscript, .ml ou .mli. Could not resolve assembly '{0}' Impossible de résoudre l'assembly '{0}' Error opening binary file '{0}': {1} Erreur lors de l'ouverture du fichier binaire '{0}' : {1} The F#-compiled DLL '{0}' needs to be recompiled to be used with this version of F# La DLL compilée F# '{0}' doit être recompilée pour pouvoir être utilisée avec cette version de F# Invalid directive. Expected '#I \"<path>\"'. Directive non valide. Attendu '#I \"<chemin>\"'. Invalid directive. Expected '#r \"<file-or-assembly>\"'. Directive non valide. Attendu '#r \"<fichier_ou_assembly>\"'. Invalid directive. Expected '#load \"<file>\" ... \"<file>\"'. Directive non valide. Attendu '#load \"<file>\" ... \"<file>\"'. Invalid directive. Expected '#time', '#time \"on\"' or '#time \"off\"'. Directive non valide. '#time', '#time \"on\"' ou '#time \"off\"' attendu. Directives inside modules are ignored Les directives contenues dans les modules sont ignorées A signature for the file or module '{0}' has already been specified Une signature pour le fichier ou le module '{0}' a déjà été spécifiée An implementation of file or module '{0}' has already been given. Compilation order is significant in F# because of type inference. You may need to adjust the order of your files to place the signature file before the implementation. In Visual Studio files are type-checked in the order they appear in the project file, which can be edited manually or adjusted using the solution explorer. Une implémentation du fichier ou du module '{0}' a déjà été fournie. L'ordre de compilation est significatif en F# en raison de l'inférence de type. Vous pouvez modifier l'ordre de vos fichiers pour placer le fichier de signature avant l'implémentation. Dans Visual Studio, les fichiers font l'objet d'une vérification de type dans l'ordre où ils apparaissent dans le fichier projet, lequel peut être modifié manuellement ou à l'aide de l'Explorateur de solutions. An implementation of the file or module '{0}' has already been given Une implémentation du fichier ou du module '{0}' a déjà été fournie The signature file '{0}' does not have a corresponding implementation file. If an implementation file exists then check the 'module' and 'namespace' declarations in the signature and implementation files match. Le fichier de signature '{0}' n'a pas de fichier d'implémentation correspondant. S'il existe un fichier d'implémentation, vérifiez que les déclarations 'module' et 'namespace' correspondent entre les fichiers de signature et d'implémentation. '{0}' is not a valid integer argument '{0}' n'est pas un argument entier valide '{0}' is not a valid floating point argument '{0}' n'est pas un argument à virgule flottante valide Unrecognized option: '{0}' Option non reconnue : '{0}' Invalid module or namespace name Nom de module ou d'espace de noms non valide Error reading/writing metadata for the F# compiled DLL '{0}'. Was the DLL compiled with an earlier version of the F# compiler? (error: '{1}'). Erreur lors de la lecture/l'écriture des métadonnées de la DLL compilée F# '{0}'. Est-ce que la DLL a été compilée avec une version antérieure du compilateur F# ? (erreur : '{1}'). The type/module '{0}' is not a concrete module or type Le type/module '{0}' n'est pas un module ou type concret The type '{0}' has an inline assembly code representation Le type '{0}' a une représentation du code assembleur inline A namespace and a module named '{0}' both occur in two parts of this assembly Un espace de noms et un module nommés tous les deux '{0}' sont présents dans deux parties de cet assembly Two modules named '{0}' occur in two parts of this assembly Deux modules nommés '{0}' sont présents dans deux parties de cet assembly Two type definitions named '{0}' occur in namespace '{1}' in two parts of this assembly Deux définitions de type nommées '{0}' sont présentes dans l'espace de noms '{1}' dans deux parties de cet assembly A module and a type definition named '{0}' occur in namespace '{1}' in two parts of this assembly Une définition de module et une définition de type nommées '{0}' sont présentes dans l'espace de noms '{1}' dans deux parties de cet assembly Invalid member signature encountered because of an earlier error Signature de membre non valide détectée en raison d'une erreur antérieure This value does not have a valid property setter type Cette valeur n'a pas de type de méthode setter de propriété valide Invalid form for a property getter. At least one '()' argument is required when using the explicit syntax. Forme non valide pour la méthode getter d'une propriété. Au moins un argument '()' est obligatoire lors de l'utilisation de la syntaxe explicite. Invalid form for a property setter. At least one argument is required. Forme non valide pour la méthode setter d'une propriété. Au moins un argument est requis. Unexpected use of a byref-typed variable Utilisation inattendue d'une variable typée byref Invalid mutation of a constant expression. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...'. Mutation non valide d'une expression constante. Copiez l'expression dans une variable locale mutable, par exemple 'let mutable x = ...'. The value has been copied to ensure the original is not mutated by this operation or because the copy is implicit when returning a struct from a member and another member is then accessed La valeur a été copiée pour garantir que la valeur d'origine n'est pas mutée par cette opération Recursively defined values cannot appear directly as part of the construction of a tuple value within a recursive binding Impossible de faire apparaître directement les valeurs définies de manière récursive dans le cadre de la construction d'une valeur basée sur un tuple dans une liaison récursive Recursive values cannot appear directly as a construction of the type '{0}' within a recursive binding. This feature has been removed from the F# language. Consider using a record instead. Impossible de faire apparaître les valeurs récursives directement en tant que construction du type '{0}' dans une liaison récursive. Cette fonctionnalité a été supprimée du langage F#. Utilisez un type enregistrement à la place. Recursive values cannot be directly assigned to the non-mutable field '{0}' of the type '{1}' within a recursive binding. Consider using a mutable field instead. Impossible d'assigner directement les valeurs récursives au champ non mutable '{0}' du type '{1}' dans une liaison récursive. Utilisez un champ mutable à la place. Unexpected decode of AutoOpenAttribute Décodage inattendu de AutoOpenAttribute Unexpected decode of InternalsVisibleToAttribute Décodage inattendu de InternalsVisibleToAttribute Unexpected decode of InterfaceDataVersionAttribute Décodage inattendu de InterfaceDataVersionAttribute Active patterns cannot return more than 7 possibilities Les modèles actifs ne peuvent pas retourner plus de 7 possibilités This is not a valid constant expression or custom attribute value Il ne s'agit pas d'une expression constante valide ou d'une valeur d'attribut personnalisé valide Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe mutability attributes differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes attributs de mutabilité sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe names differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes noms sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe compiled names differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes noms compilés sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe display names differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes noms complets sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe accessibility specified in the signature is more than that specified in the implementation Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'accessibilité spécifiée dans la signature est supérieure à celle spécifiée dans l'implémentation Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe inline flags differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes indicateurs inline sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe literal constant values and/or attributes differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes valeurs et/ou attributs de constante littérale sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is a type function and the other is not. The signature requires explicit type parameters if they are present in the implementation. Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est une fonction de type mais pas l'autre. La signature requiert des paramètres de type explicite s'ils sont présents dans l'implémentation. Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe respective type parameter counts differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLe nombre de paramètres de type respectifs est différent Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe types differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes types sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is an extension member and the other is not Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est un membre d'extension mais pas l'autre Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nAn arity was not inferred for this value Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nAucune arité n'a été déduite pour cette valeur Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe number of generic parameters in the signature and implementation differ (the signature declares {3} but the implementation declares {4} Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLe nombre de paramètres génériques est différent entre la signature et l'implémentation (la signature déclare {3} mais l'implémentation déclare {4} Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe generic parameters in the signature and implementation have different kinds. Perhaps there is a missing [<Measure>] attribute. Le module '{0}' contient\n {1}, \nmais sa signature spécifie\n {2} \nLes paramètres génériques dans la signature et l'implémentation ont des genres différents. Un attribut [<Measure>] est peut-être manquant. Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe arities in the signature and implementation differ. The signature specifies that '{3}' is function definition or lambda expression accepting at least {4} argument(s), but the implementation is a computed function value. To declare that a computed function value is a permitted implementation simply parenthesize its type in the signature, e.g.\n\tval {5}: int -> (int -> int)\ninstead of\n\tval {6}: int -> int -> int. Le module '{0}' contient\n {1}, \nmais sa signature spécifie\n {2} \nLes arités sont différentes dans la signature et dans l'implémentation. La signature spécifie que '{3}' est une définition de fonction ou une expression lambda qui accepte au moins {4} argument(s), mais l'implémentation est une valeur de fonction calculée. Pour déclarer qu'une valeur de fonction calculée est une implémentation autorisée, mettez simplement entre parenthèses son type dans la signature, par ex.\n\tval {5}: int -> (int -> int)\nau lieu de\n\tval {6}: int -> int -> int. Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe CLI member names differ Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLes noms de membres CLI sont différents Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is static and the other isn't Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est statique mais pas l'autre Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is virtual and the other isn't Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est virtuel mais pas l'autre Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is abstract and the other isn't Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est abstrait mais pas l'autre Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is final and the other isn't Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est final mais pas l'autre Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is marked as an override and the other isn't Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est marqué en tant que substitution mais pas l'autre Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nOne is a constructor/property and the other is not Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nL'un est un constructeur/une propriété mais pas l'autre Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe compiled representation of this method is as a static member but the signature indicates its compiled representation is as an instance member Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLa représentation compilée de cette méthode est celle d'un membre statique, mais la signature indique que sa représentation compilée est celle d'un membre d'instance Module '{0}' contains\n {1} \nbut its signature specifies\n {2} \nThe compiled representation of this method is as an instance member, but the signature indicates its compiled representation is as a static member Le module '{0}' contient\n {1} \nmais sa signature spécifie\n {2} \nLa représentation compilée de cette méthode est celle d'un membre d'instance, mais la signature indique que sa représentation compilée est celle d'un membre statique The {0} definitions in the signature and implementation are not compatible because the names differ. The type is called '{1}' in the signature file but '{2}' in implementation. Les {0} définitions dans la signature et l'implémentation ne sont pas compatibles, car les noms sont différents. Le type est appelé '{1}' dans le fichier de signature et '{2}' dans l'implémentation. The {0} definitions for type '{1}' in the signature and implementation are not compatible because the respective type parameter counts differ Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le nombre de paramètres de type respectifs est différent The {0} definitions for type '{1}' in the signature and implementation are not compatible because the accessibility specified in the signature is more than that specified in the implementation Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car l'accessibilité spécifiée dans la signature est supérieure à celle spécifiée dans l'implémentation The {0} definitions for type '{1}' in the signature and implementation are not compatible because the signature requires that the type supports the interface {2} but the interface has not been implemented Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car la signature requiert que le type prenne en charge l'interface {2} mais l'interface n'a pas été implémentée The {0} definitions for type '{1}' in the signature and implementation are not compatible because the implementation says this type may use nulls as a representation but the signature does not Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car l'implémentation indique que ce type peut utiliser des valeurs Null comme représentation, contrairement à la signature The {0} definitions for type '{1}' in the signature and implementation are not compatible because the implementation says this type may use nulls as an extra value but the signature does not Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car l'implémentation indique que ce type peut utiliser des valeurs Null comme valeurs supplémentaires, contrairement à la signature The {0} definitions for type '{1}' in the signature and implementation are not compatible because the signature says this type may use nulls as a representation but the implementation does not Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car la signature indique que ce type peut utiliser des valeurs Null comme représentation, contrairement à l'implémentation The {0} definitions for type '{1}' in the signature and implementation are not compatible because the signature says this type may use nulls as an extra value but the implementation does not Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car la signature indique que ce type peut utiliser des valeurs Null comme valeurs supplémentaires, contrairement à l'implémentation The {0} definitions for type '{1}' in the signature and implementation are not compatible because the implementation type is sealed but the signature implies it is not. Consider adding the [<Sealed>] attribute to the signature. Les définitions {0} du type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le type d'implémentation est sealed et la signature suggère qu'il ne l'est pas. Ajoutez l'attribut [<Sealed>] à la signature. The {0} definitions for type '{1}' in the signature and implementation are not compatible because the implementation type is not sealed but signature implies it is. Consider adding the [<Sealed>] attribute to the implementation. Les définitions {0} du type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le type d'implémentation n'est pas sealed et la signature suggère qu'il l'est. Ajoutez l'attribut [<Sealed>] à l'implémentation. The {0} definitions for type '{1}' in the signature and implementation are not compatible because the implementation is an abstract class but the signature is not. Consider adding the [<AbstractClass>] attribute to the signature. Les définitions {0} du type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car l'implémentation est une classe abstraite et la signature ne l'est pas. Ajoutez l'attribut [<AbstractClass>] à la signature. The {0} definitions for type '{1}' in the signature and implementation are not compatible because the signature is an abstract class but the implementation is not. Consider adding the [<AbstractClass>] attribute to the implementation. Les définitions {0} pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car la signature est une classe abstraite et l'implémentation ne l'est pas. Ajoutez l'attribut [<AbstractClass>] à l'implémentation. The {0} definitions for type '{1}' in the signature and implementation are not compatible because the types have different base types Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car les types ont des types de base différents The {0} definitions for type '{1}' in the signature and implementation are not compatible because the number of {2}s differ Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le nombre de {2} est différent The {0} definitions for type '{1}' in the signature and implementation are not compatible because the signature defines the {2} '{3}' but the implementation does not (or does, but not in the same order) Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car la signature définit le {2} '{3}' mais l'implémentation ne le fait pas (ou elle le fait mais dans un ordre différent) The {0} definitions for type '{1}' in the signature and implementation are not compatible because the implementation defines the {2} '{3}' but the signature does not (or does, but not in the same order) Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car l'implémentation définit le {2} '{3}' mais la signature ne le fait pas (ou elle le fait mais dans un ordre différent) The {0} definitions for type '{1}' in the signature and implementation are not compatible because the implementation defines a struct but the signature defines a type with a hidden representation Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car l'implémentation définit un struct alors que la signature définit un type avec une représentation masquée The {0} definitions for type '{1}' in the signature and implementation are not compatible because a CLI type representation is being hidden by a signature Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car une représentation de type CLI est masquée par une signature The {0} definitions for type '{1}' in the signature and implementation are not compatible because a type representation is being hidden by a signature Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car une représentation de type est masquée par une signature The {0} definitions for type '{1}' in the signature and implementation are not compatible because the types are of different kinds Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car les types sont de différents genres The {0} definitions for type '{1}' in the signature and implementation are not compatible because the IL representations differ Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car les représentations IL (Intermediate Language) sont différentes The {0} definitions for type '{1}' in the signature and implementation are not compatible because the representations differ Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car les représentations sont différentes The {0} definitions for type '{1}' in the signature and implementation are not compatible because the field {2} was present in the implementation but not in the signature Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le champ {2} était présent dans l'implémentation mais pas dans la signature The {0} definitions for type '{1}' in the signature and implementation are not compatible because the order of the fields is different in the signature and implementation Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car l'ordre des champs est différent entre la signature et l'implémentation The {0} definitions for type '{1}' in the signature and implementation are not compatible because the field {2} was required by the signature but was not specified by the implementation Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le champ {2} a été demandé par la signature mais n'a pas été spécifié par l'implémentation The {0} definitions for type '{1}' in the signature and implementation are not compatible because the field '{2}' was present in the implementation but not in the signature. Struct types must now reveal their fields in the signature for the type, though the fields may still be labelled 'private' or 'internal'. Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le champ '{2}' était présent dans l'implémentation mais pas dans la signature. Les types struct doivent désormais révéler leurs champs dans la signature relative au type ; toutefois, les champs peuvent continuer à être étiquetés 'private' ou 'internal'. The {0} definitions for type '{1}' in the signature and implementation are not compatible because the abstract member '{2}' was required by the signature but was not specified by the implementation Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le membre abstrait '{2}' a été requis par la signature mais n'a pas été spécifié par l'implémentation The {0} definitions for type '{1}' in the signature and implementation are not compatible because the abstract member '{2}' was present in the implementation but not in the signature Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car le membre abstrait '{2}' était présent dans l'implémentation mais pas dans la signature The {0} definitions for type '{1}' in the signature and implementation are not compatible because the signature declares a {2} while the implementation declares a {3} Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car la signature déclare {2} alors que l'implémentation déclare {3} The {0} definitions for type '{1}' in the signature and implementation are not compatible because the abbreviations differ: {2} versus {3} Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car les abréviations sont différentes : {2} par opposition à {3} The {0} definitions for type '{1}' in the signature and implementation are not compatible because an abbreviation is being hidden by a signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car une abréviation est masquée par une signature. L'abréviation doit être visible par les autres langages CLI. Rendez l'abréviation visible dans la signature. The {0} definitions for type '{1}' in the signature and implementation are not compatible because the signature has an abbreviation while the implementation does not Les {0} définitions pour le type '{1}' dans la signature et l'implémentation ne sont pas compatibles, car la signature a une abréviation, contrairement à l'implémentation The module contains the constructor\n {0} \nbut its signature specifies\n {1} \nThe names differ Le module contient le constructeur\n {0} \nmais sa signature spécifie\n {1} \nLes noms sont différents The module contains the constructor\n {0} \nbut its signature specifies\n {1} \nThe respective number of data fields differ Le module contient le constructeur\n {0} \nmais sa signature spécifie\n {1} \nLe nombre de champs de données respectifs est différent The module contains the constructor\n {0} \nbut its signature specifies\n {1} \nThe types of the fields differ Le module contient le constructeur\n {0} \nmais sa signature spécifie\n {1} \nLes types des champs sont différents The module contains the constructor\n {0} \nbut its signature specifies\n {1} \nthe accessibility specified in the signature is more than that specified in the implementation Le module contient le constructeur\n {0} \nmais sa signature spécifie\n {1} \nL'accessibilité spécifiée dans la signature est supérieure à celle spécifiée dans l'implémentation The module contains the field\n {0} \nbut its signature specifies\n {1} \nThe names differ Le module contient le champ\n {0} \nmais sa signature spécifie\n {1} \nLes noms sont différents The module contains the field\n {0} \nbut its signature specifies\n {1} \nthe accessibility specified in the signature is more than that specified in the implementation Le module contient le champ\n {0} \nmais sa signature spécifie\n {1} \nL'accessibilité spécifiée dans la signature est supérieure à celle spécifiée dans l'implémentation The module contains the field\n {0} \nbut its signature specifies\n {1} \nThe 'static' modifiers differ Le module contient le champ\n {0} \nmais sa signature spécifie\n {1} \nLes modificateurs 'static' sont différents The module contains the field\n {0} \nbut its signature specifies\n {1} \nThe 'mutable' modifiers differ Le module contient le champ\n {0} \nmais sa signature spécifie\n {1} \nLes modificateurs 'mutable' sont différents The module contains the field\n {0} \nbut its signature specifies\n {1} \nThe 'literal' modifiers differ Le module contient le champ\n {0} \nmais sa signature spécifie\n {1} \nLes modificateurs 'literal' sont différents The module contains the field\n {0} \nbut its signature specifies\n {1} \nThe types differ Le module contient le champ\n {0} \nmais sa signature spécifie\n {1} \nLes types sont différents The implicit instantiation of a generic construct at or near this point could not be resolved because it could resolve to multiple unrelated types, e.g. '{0}' and '{1}'. Consider using type annotations to resolve the ambiguity Impossible de résoudre l'instanciation implicite d'une construction générique à cet emplacement ou à proximité, car elle peut être résolue en plusieurs types non liés, par exemple '{0}' et '{1}'. Utilisez des annotations de type pour résoudre l'ambigüité Could not resolve the ambiguity inherent in the use of a 'printf'-style format string Impossible de résoudre l'ambigüité inhérente à l'utilisation d'une chaîne de format de style 'printf' Could not resolve the ambiguity in the use of a generic construct with an 'enum' constraint at or near this position Impossible de résoudre l'ambigüité liée à l'utilisation d'une construction générique avec une contrainte 'enum' à cette position ou à proximité Could not resolve the ambiguity in the use of a generic construct with a 'delegate' constraint at or near this position Impossible de résoudre l'ambigüité liée à l'utilisation d'une construction générique avec une contrainte 'delegate' à cette position ou à proximité Invalid value Valeur non valide The signature and implementation are not compatible because the respective type parameter counts differ La signature et l'implémentation ne sont pas compatibles, car le nombre de paramètres de type respectifs est différent The signature and implementation are not compatible because the type parameter in the class/signature has a different compile-time requirement to the one in the member/implementation La signature et l'implémentation ne sont pas compatibles, car le paramètre de type de la classe/signature n'a pas la même exigence au moment de la compilation que celui du membre/de l'implémentation The signature and implementation are not compatible because the declaration of the type parameter '{0}' requires a constraint of the form {1} La signature et l'implémentation ne sont pas compatibles, car la déclaration du paramètre de type '{0}' requiert une contrainte sous la forme {1} The signature and implementation are not compatible because the type parameter '{0}' has a constraint of the form {1} but the implementation does not. Either remove this constraint from the signature or add it to the implementation. La signature et l'implémentation ne sont pas compatibles, car le paramètre de type '{0}' a une contrainte sous la forme {1} mais l'implémentation n'en a pas. Vous devez soit supprimer cette contrainte de la signature, soit l'ajouter à l'implémentation. The type '{0}' implements 'System.IComparable'. Consider also adding an explicit override for 'Object.Equals' Le type '{0}' implémente 'System.IComparable'. Ajoutez également une substitution explicite pour 'Object.Equals' The type '{0}' implements 'System.IComparable' explicitly but provides no corresponding override for 'Object.Equals'. An implementation of 'Object.Equals' has been automatically provided, implemented via 'System.IComparable'. Consider implementing the override 'Object.Equals' explicitly Le type '{0}' implémente explicitement 'System.IComparable' mais ne fournit aucune substitution correspondante pour 'Object.Equals'. Une implémentation de 'Object.Equals' a été fournie automatiquement, implémentée via 'System.IComparable'. Implémentez explicitement la substitution 'Object.Equals' The struct, record or union type '{0}' has an explicit implementation of 'Object.GetHashCode' or 'Object.Equals'. You must apply the 'CustomEquality' attribute to the type Le type struct, enregistrement ou union '{0}' a une implémentation explicite de 'Object.GetHashCode' ou 'Object.Equals'. Vous devez appliquer l'attribut 'CustomEquality' au type The struct, record or union type '{0}' has an explicit implementation of 'Object.GetHashCode'. Consider implementing a matching override for 'Object.Equals(obj)' Le type struct, enregistrement ou union '{0}' a une implémentation explicite de 'Object.GetHashCode'. Implémentez une substitution correspondante pour 'Object.Equals(obj)' The struct, record or union type '{0}' has an explicit implementation of 'Object.Equals'. Consider implementing a matching override for 'Object.GetHashCode()' Le type struct, enregistrement ou union '{0}' a une implémentation explicite de 'Object.Equals'. Implémentez une substitution correspondante pour 'Object.GetHashCode()' The exception definitions are not compatible because a CLI exception mapping is being hidden by a signature. The exception mapping must be visible to other modules. The module contains the exception definition\n {0} \nbut its signature specifies\n\t{1} Les définitions de l'exception ne sont pas compatibles, car le mappage d'une exception CLI est masqué par une signature. Le mappage de l'exception doit être visible par les autres modules. Le module contient la définition de l'exception\n {0} \nmais sa signature spécifie\n\t{1} The exception definitions are not compatible because the CLI representations differ. The module contains the exception definition\n {0} \nbut its signature specifies\n\t{1} Les définitions de l'exception ne sont pas compatibles, car les représentations CLI sont différentes. Le module contient la définition de l'exception\n {0} \nmais sa signature spécifie\n\t{1} The exception definitions are not compatible because the exception abbreviation is being hidden by the signature. The abbreviation must be visible to other CLI languages. Consider making the abbreviation visible in the signature. The module contains the exception definition\n {0} \nbut its signature specifies\n\t{1}. Les définitions de l'exception ne sont pas compatibles, car l'abréviation de l'exception est masquée par la signature. L'abréviation doit être visible par les autres langages CLI. Rendez l'abréviation visible dans la signature. Le module contient la définition de l'exception\n {0} \nmais sa signature spécifie\n\t{1}. The exception definitions are not compatible because the exception abbreviations in the signature and implementation differ. The module contains the exception definition\n {0} \nbut its signature specifies\n\t{1}. Les définitions de l'exception ne sont pas compatibles, car les abréviations de l'exception sont différentes entre la signature et l'implémentation. Le module contient la définition de l'exception\n {0} \nmais sa signature spécifie\n\t{1}. The exception definitions are not compatible because the exception declarations differ. The module contains the exception definition\n {0} \nbut its signature specifies\n\t{1}. Les définitions de l'exception ne sont pas compatibles, car les déclarations de l'exception sont différentes. Le module contient la définition de l'exception\n {0} \nmais sa signature spécifie\n\t{1}. The exception definitions are not compatible because the field '{0}' was required by the signature but was not specified by the implementation. The module contains the exception definition\n {1} \nbut its signature specifies\n\t{2}. Les définitions de l'exception ne sont pas compatibles, car le champ '{0}' était requis par la signature mais n'était pas spécifiée par l'implémentation. Le module contient la définition de l'exception\n {1} \nmais sa signature spécifie\n\t{2}. The exception definitions are not compatible because the field '{0}' was present in the implementation but not in the signature. The module contains the exception definition\n {1} \nbut its signature specifies\n\t{2}. Les définitions de l'exception ne sont pas compatibles, car le champ '{0}' était présent dans l'implémentation mais pas dans la signature. Le module contient la définition de l'exception\n {1} \nmais sa signature spécifie\n\t{2}. The exception definitions are not compatible because the order of the fields is different in the signature and implementation. The module contains the exception definition\n {0} \nbut its signature specifies\n\t{1}. Les définitions de l'exception ne sont pas compatibles, car l'ordre des champs est différent entre la signature et l'implémentation. Le module contient la définition de l'exception\n {0} \nmais sa signature spécifie\n\t{1}. The namespace or module attributes differ between signature and implementation Les attributs de l'espace de noms ou du module sont différents entre la signature et l'implémentation This method is over-constrained in its type parameters Cette méthode est contrainte de manière excessive dans ses paramètres de type No implementations of '{0}' had the correct number of arguments and type parameters. The required signature is '{1}'. Aucune implémentation de '{0}' n'avait le nombre approprié d'arguments et de paramètres de type. La signature requise est '{1}'. The override for '{0}' was ambiguous La substitution pour '{0}' était ambigüe More than one override implements '{0}' Plusieurs substitutions implémentent '{0}' The method '{0}' is sealed and cannot be overridden La méthode '{0}' est sealed et ne peut pas être substituée The override '{0}' implements more than one abstract slot, e.g. '{1}' and '{2}' La substitution '{0}' implémente plusieurs emplacements abstraits, par exemple '{1}' et '{2}' Duplicate or redundant interface Interface dupliquée ou redondante The interface '{0}' is included in multiple explicitly implemented interface types. Add an explicit implementation of this interface. L'interface '{0}' est incluse dans plusieurs types interface implémentés explicitement. Ajoutez une implémentation explicite de cette interface. The named argument '{0}' has been assigned more than one value Plusieurs valeurs ont été affectées à l'argument nommé '{0}' No implementation was given for '{0}' Aucune implémentation n'a été fournie pour '{0}' No implementation was given for '{0}'. Note that all interface members must be implemented and listed under an appropriate 'interface' declaration, e.g. 'interface ... with member ...'. Aucune implémentation n'a été fournie pour '{0}'. Remarquez que tous les membres d'interface doivent être implémentés et listés sous une déclaration 'interface' appropriée, par exemple 'interface ... with member ...'. The member '{0}' does not have the correct number of arguments. The required signature is '{1}'. Le membre '{0}' n'a pas le nombre approprié d'arguments. La signature requise est '{1}'. The member '{0}' does not have the correct number of method type parameters. The required signature is '{1}'. Le membre '{0}' n'a pas le nombre approprié de paramètres de type de méthode. La signature requise est '{1}'. The member '{0}' does not have the correct kinds of generic parameters. The required signature is '{1}'. Le membre '{0}' n'a pas les genres appropriés de paramètres génériques. La signature requise est '{1}'. The member '{0}' cannot be used to implement '{1}'. The required signature is '{2}'. Impossible d'utiliser le membre '{0}' pour implémenter '{1}'. La signature requise est '{2}'. Error while parsing embedded IL Erreur lors de l'analyse du code IL (Intermediate Language) incorporé Error while parsing embedded IL type Erreur lors de l'analyse du type IL (Intermediate Language) incorporé This indexer notation has been removed from the F# language Cette notation de l'indexeur a été supprimée du langage F# Invalid expression on left of assignment Expression non valide à gauche de l'assignation The 'ReferenceEquality' attribute cannot be used on structs. Consider using the 'StructuralEquality' attribute instead, or implement an override for 'System.Object.Equals(obj)'. Impossible d'utiliser l'attribut 'ReferenceEquality' sur des structs. Utilisez l'attribut 'StructuralEquality' à la place, ou implémentez une substitution pour 'System.Object.Equals(obj)'. This type uses an invalid mix of the attributes 'NoEquality', 'ReferenceEquality', 'StructuralEquality', 'NoComparison' and 'StructuralComparison' Ce type utilise un mélange non valide des attributs 'NoEquality', 'ReferenceEquality', 'StructuralEquality', 'NoComparison' et 'StructuralComparison' The 'NoEquality' attribute must be used in conjunction with the 'NoComparison' attribute L'attribut 'NoEquality' doit être utilisé conjointement avec l'attribut 'NoComparison' The 'StructuralComparison' attribute must be used in conjunction with the 'StructuralEquality' attribute L'attribut 'StructuralComparison' doit être utilisé conjointement avec l'attribut 'StructuralEquality' The 'StructuralEquality' attribute must be used in conjunction with the 'NoComparison' or 'StructuralComparison' attributes L'attribut 'StructuralEquality' doit être utilisé conjointement avec les attributs 'NoComparison' ou 'StructuralComparison' A type cannot have both the 'ReferenceEquality' and 'StructuralEquality' or 'StructuralComparison' attributes Un type ne peut pas avoir à la fois les attributs 'ReferenceEquality' et 'StructuralEquality' ou 'StructuralComparison' Only record, union, exception and struct types may be augmented with the 'ReferenceEquality', 'StructuralEquality' and 'StructuralComparison' attributes Seuls les types enregistrement, union, exception et struct peuvent être augmentés avec les attributs 'ReferenceEquality', 'StructuralEquality' et 'StructuralComparison' A type with attribute 'ReferenceEquality' cannot have an explicit implementation of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' Un type avec l'attribut 'ReferenceEquality' ne peut pas avoir d'implémentation explicite de 'Object.Equals(obj)', 'System.IEquatable<_>' ou 'System.Collections.IStructuralEquatable' A type with attribute 'CustomEquality' must have an explicit implementation of at least one of 'Object.Equals(obj)', 'System.IEquatable<_>' or 'System.Collections.IStructuralEquatable' Un type avec l'attribut 'CustomEquality' doit avoir une implémentation explicite d'au moins un des éléments 'Object.Equals(obj)', 'System.IEquatable<_>' ou 'System.Collections.IStructuralEquatable' A type with attribute 'CustomComparison' must have an explicit implementation of at least one of 'System.IComparable' or 'System.Collections.IStructuralComparable' Un type avec l'attribut 'CustomComparison' doit avoir au moins une implémentation explicite de 'System.IComparable' ou 'System.Collections.IStructuralComparable' A type with attribute 'NoEquality' should not usually have an explicit implementation of 'Object.Equals(obj)'. Disable this warning if this is intentional for interoperability purposes Un type avec l'attribut 'NoEquality' ne doit généralement pas avoir une implémentation explicite de 'Object.Equals(obj)'. Désactivez cet avertissement s'il résulte d'une action intentionnelle à des fins d'interopérabilité A type with attribute 'NoComparison' should not usually have an explicit implementation of 'System.IComparable', 'System.IComparable<_>' or 'System.Collections.IStructuralComparable'. Disable this warning if this is intentional for interoperability purposes Un type avec l'attribut 'NoComparison' ne doit généralement pas avoir d'implémentation explicite de 'System.IComparable', 'System.IComparable<_>' ou 'System.Collections.IStructuralComparable'. Désactivez cet avertissement si l'implémentation est intentionnelle ou à des fins d'interopérabilité The 'CustomEquality' attribute must be used in conjunction with the 'NoComparison' or 'CustomComparison' attributes L'attribut 'CustomEquality' doit être utilisé conjointement avec les attributs 'NoComparison' ou 'CustomComparison' Positional specifiers are not permitted in format strings Les spécificateurs de position ne sont pas autorisés dans les chaînes de format Missing format specifier Spécificateur de format manquant '{0}' flag set twice Indicateur '{0}' défini à deux reprises Prefix flag (' ' or '+') set twice Indicateur de préfixe (' ' ou '+') défini à deux reprises The # formatting modifier is invalid in F# Le modificateur de mise en forme # n'est pas valide en F# Bad precision in format specifier Précision incorrecte du spécificateur de format Bad width in format specifier Largeur incorrecte du spécificateur de format '{0}' format does not support '0' flag Le format '{0}' ne prend pas en charge l'indicateur '0' Precision missing after the '.' Précision manquante après le '.' '{0}' format does not support precision Le format '{0}' ne prend pas en charge la précision Bad format specifier (after l or L): Expected ld,li,lo,lu,lx or lX. In F# code you can use %d, %x, %o or %u instead, which are overloaded to work with all basic integer types. Spécificateur de format incorrect (après l ou L) : ld,li,lo,lu,lx ou lX attendu. En F#, vous pouvez utiliser %d, %x, %o ou %u à la place, qui sont surchargés pour fonctionner avec tous les types entiers de base. The 'l' or 'L' in this format specifier is unnecessary. In F# code you can use %d, %x, %o or %u instead, which are overloaded to work with all basic integer types. Le 'l' ou 'L' dans ce spécificateur de format est inutile. En F#, vous pouvez utiliser %d, %x, %o ou %u à la place, qui sont surchargés pour fonctionner avec tous les types entiers de base. The 'h' or 'H' in this format specifier is unnecessary. You can use %d, %x, %o or %u instead, which are overloaded to work with all basic integer types. Le 'h' ou 'H' dans ce spécificateur de format est inutile. Vous pouvez utiliser %d, %x, %o ou %u à la place, qui sont surchargés pour fonctionner avec tous les types entiers de base. '{0}' does not support prefix '{1}' flag '{0}' ne prend pas en charge l'indicateur de préfixe '{1}' Bad format specifier: '{0}' Spécificateur de format incorrect : '{0}' System.Environment.Exit did not exit System.Environment.Exit n'est pas sorti The treatment of this operator is now handled directly by the F# compiler and its meaning cannot be redefined Le traitement de cet opérateur est désormais géré directement par le compilateur F# et il est impossible de redéfinir sa signification A protected member is called or 'base' is being used. This is only allowed in the direct implementation of members since they could escape their object scope. Un membre protégé est appelé ou 'base' est utilisé. Cela n'est autorisé que dans l'implémentation directe des membres, car ils peuvent sortir de la portée de leurs objets. The byref-typed variable '{0}' is used in an invalid way. Byrefs cannot be captured by closures or passed to inner functions. La variable typée byref '{0}' est utilisée de manière incorrecte. Impossible de capturer les types byref par des fermetures ou de les passer à des fonctions internes. The 'base' keyword is used in an invalid way. Base calls cannot be used in closures. Consider using a private member to make base calls. Le mot clé 'base' est utilisé de manière incorrecte. Impossible d'utiliser les appels de base dans les fermetures. Utilisez un membre privé pour effectuer les appels de base. The variable '{0}' is used in an invalid way La variable '{0}' est utilisée de manière incorrecte The type '{0}' is less accessible than the value, member or type '{1}' it is used in. Le type '{0}' est moins accessible que la valeur, le membre ou le type '{1}' dans lequel il est utilisé. 'System.Void' can only be used as 'typeof<System.Void>' in F# 'System.Void' peut uniquement être utilisé sous la forme 'typeof<System.Void>' dans F# A type instantiation involves a byref type. This is not permitted by the rules of Common IL. Une instanciation de type implique un type byref. Cela n'est pas autorisé par les règles du langage CIL (Common Intermediate Language). Calls to 'reraise' may only occur directly in a handler of a try-with Les appels à 'reraise' ne peuvent se produire directement que dans un gestionnaire de try-with Expression-splicing operators may only be used within quotations Les opérateurs d'ajout d'expressions ne peuvent être utilisés qu'entre des quotations First-class uses of the expression-splicing operator are not permitted Les utilisations de première classe de l'opérateur d'ajout d'expression ne sont pas autorisées First-class uses of the address-of operators are not permitted Les utilisations de première classe d'opérateurs d'adresses ne sont pas autorisées First-class uses of the 'reraise' function is not permitted Les utilisations de première classe de la fonction 'reraise' ne sont pas autorisées The byref typed value '{0}' cannot be used at this point Impossible d'utiliser la valeur typée byref '{0}' actuellement 'base' values may only be used to make direct calls to the base implementations of overridden members Les valeurs 'base' ne peuvent être utilisées que pour effectuer des appels directs aux implémentations de base des membres substitués The address of the variable '{0}' cannot be used at this point Impossible d'utiliser l'adresse de la variable '{0}' actuellement The address of the static field '{0}' cannot be used at this point Impossible d'utiliser l'adresse du champ statique '{0}' actuellement The address of the field '{0}' cannot be used at this point Impossible d'utiliser l'adresse du champ '{0}' actuellement The address of an array element cannot be used at this point Impossible d'utiliser l'adresse d'un élément de tableau actuellement The type of a first-class function cannot contain byrefs Une fonction de première classe ne peut pas contenir de types byref A method return type would contain byrefs which is not permitted Le type de retour d'une méthode contient des types byref, ce qui n'est pas autorisé Invalid custom attribute value (not a constant or literal) Valeur d'attribut personnalisé non valide (n'est pas une constante ou un littéral) The attribute type '{0}' has 'AllowMultiple=false'. Multiple instances of this attribute cannot be attached to a single language element. Le type d'attribut '{0}' a 'AllowMultiple=false'. Impossible d'attacher plusieurs instances de cet attribut à un élément de langage unique. The member '{0}' is used in an invalid way. A use of '{1}' has been inferred prior to its definition at or near '{2}'. This is an invalid forward reference. Le membre '{0}' est utilisé de manière incorrecte. Une utilisation de '{1}' a été déduite avant sa définition au niveau ou à proximité de '{2}'. Il s'agit d'une référence anticipée non valide. A byref typed value would be stored here. Top-level let-bound byref values are not permitted. Une valeur typée byref doit être stockée ici. Les valeurs byref liées à let de niveau supérieur ne sont pas autorisées. [<ReflectedDefinition>] terms cannot contain uses of the prefix splice operator '%' Les conditions de [<ReflectedDefinition>] ne peuvent pas contenir d'utilisations de l'opérateur d'ajout de préfixe '%' A function labeled with the 'EntryPointAttribute' attribute must be the last declaration in the last file in the compilation sequence. Une fonction étiquetée avec l'attribut 'EntryPointAttribute' doit être la dernière déclaration du dernier fichier de la séquence de compilation. compiled form of the union case forme compilée du cas d'union default augmentation of the union case augmentation par défaut du cas d'union The property '{0}' has the same name as a method in type '{1}'. La propriété '{0}' a le même nom qu'une méthode dans le type '{1}'. The property '{0}' of type '{1}' has a getter and a setter that do not match. If one is abstract then the other must be as well. La propriété '{0}' de type '{1}' a une méthode getter et une méthode setter qui ne correspondent pas. Si l'une est abstraite, l'autre doit l'être également. The property '{0}' has the same name as another property in type '{1}', but one takes indexer arguments and the other does not. You may be missing an indexer argument to one of your properties. La propriété '{0}' a le même nom qu'une autre propriété dans le type '{1}'. Toutefois, l'une d'elles accepte les arguments de l'indexeur mais pas l'autre. Il manque peut-être un argument d'indexeur dans l'une de vos propriétés. A type would store a byref typed value. This is not permitted by Common IL. Un type doit stocker une valeur typée byref. Cela n'est pas autorisé par le langage CIL (Common Intermediate Language). Duplicate method. The method '{0}' has the same name and signature as another method in type '{1}'. Méthode dupliquée. La méthode '{0}' a le même nom et la même signature qu'une autre méthode dans le type '{1}'. Duplicate method. The method '{0}' has the same name and signature as another method in type '{1}' once tuples, functions, units of measure and/or provided types are erased. Méthode dupliquée. La méthode '{0}' a le même nom et la même signature qu'une autre méthode dans le type '{1}', une fois les tuples, fonctions, unités de mesure et/ou types fournis effacés. The method '{0}' has curried arguments but has the same name as another method in type '{1}'. Methods with curried arguments cannot be overloaded. Consider using a method taking tupled arguments. La méthode '{0}' a des arguments curryfiés mais elle comporte le même nom qu'une autre méthode dans le type '{1}'. Impossible de surcharger les méthodes ayant des arguments curryfiés. Utilisez une méthode qui accepte des arguments basés sur des tuples. Methods with curried arguments cannot declare 'out', 'ParamArray', 'optional', 'ReflectedDefinition', 'byref', 'CallerLineNumber', 'CallerMemberName', or 'CallerFilePath' arguments Les méthodes avec des arguments curryfiés ne peuvent pas déclarer d'arguments 'out', 'ParamArray', 'optional', 'ReflectedDefinition', 'byref', 'CallerLineNumber', 'CallerMemberName' ou 'CallerFilePath' Duplicate property. The property '{0}' has the same name and signature as another property in type '{1}'. Propriété dupliquée. La propriété '{0}' a le même nom et la même signature qu'une autre propriété dans le type '{1}'. Duplicate property. The property '{0}' has the same name and signature as another property in type '{1}' once tuples, functions, units of measure and/or provided types are erased. Propriété dupliquée. La propriété '{0}' a le même nom et la même signature qu'une autre propriété dans le type '{1}', une fois les tuples, fonctions, unités de mesure et/ou types fournis effacés. Duplicate method. The abstract method '{0}' has the same name and signature as an abstract method in an inherited type. Méthode dupliquée. La méthode abstract '{0}' a le même nom et la même signature qu'une méthode abstract d'un type hérité. Duplicate method. The abstract method '{0}' has the same name and signature as an abstract method in an inherited type once tuples, functions, units of measure and/or provided types are erased. Méthode dupliquée. La méthode abstract '{0}' a le même nom et la même signature qu'une méthode abstract d'un type hérité, une fois les tuples, fonctions, unités de mesure et/ou types fournis effacés. This type implements the same interface at different generic instantiations '{0}' and '{1}'. This is not permitted in this version of F#. Ce type implémente la même interface à des instanciations génériques différentes '{0}' et '{1}'. Cela n'est pas autorisé dans cette version de F#. The type of a field using the 'DefaultValue' attribute must admit default initialization, i.e. have 'null' as a proper value or be a struct type whose fields all admit default initialization. You can use 'DefaultValue(false)' to disable this check Le type d'un champ qui utilise l'attribut 'DefaultValue' doit admettre l'initialisation par défaut, c'est-à-dire qu'il doit avoir la valeur 'null' comme valeur appropriée ou être un type struct dont les champs admettent tous l'initialisation par défaut. Vous pouvez utiliser 'DefaultValue(false)' pour désactiver cette vérification The type abbreviation contains byrefs. This is not permitted by F#. L'abréviation de type contient des types byref. Cela n'est pas autorisé en F#. The variable '{0}' is bound in a quotation but is used as part of a spliced expression. This is not permitted since it may escape its scope. La variable '{0}' est liée dans une quotation mais est utilisée dans le cadre d'une expression ajoutée. Cela n'est pas autorisé, car elle peut sortir de sa portée. Quotations cannot contain uses of generic expressions Les quotations ne peuvent pas contenir d'utilisations d'expressions génériques Quotations cannot contain function definitions that are inferred or declared to be generic. Consider adding some type constraints to make this a valid quoted expression. Les citations ne peuvent pas contenir de définitions de fonction déduites ou déclarées comme étant génériques. Ajoutez des contraintes de type pour rendre cette expression citée valide. Quotations cannot contain object expressions Les quotations ne peuvent pas contenir d'expressions d'objet Quotations cannot contain expressions that take the address of a field Les quotations ne peuvent pas contenir d'expressions qui acceptent l'adresse d'un champ Quotations cannot contain expressions that fetch static fields Les quotations ne peuvent pas contenir d'expressions qui récupèrent des champs statiques Quotations cannot contain inline assembly code or pattern matching on arrays Les quotations ne peuvent pas contenir de code assembleur inline ou de critères spéciaux dans les tableaux Quotations cannot contain descending for loops Les quotations ne peuvent pas contenir d'ordre décroissant pour les boucles Quotations cannot contain expressions that fetch union case indexes Les quotations ne peuvent pas contenir d'expressions qui récupèrent des index de cas d'union Quotations cannot contain expressions that set union case fields Les quotations ne peuvent pas contenir d'expressions qui définissent des champs de cas d'union Quotations cannot contain expressions that set fields in exception values Les quotations ne peuvent pas contenir d'expressions qui définissent des champs dans des valeurs d'exception Quotations cannot contain expressions that require byref pointers Les quotations ne peuvent pas contenir d'expressions qui requièrent des pointeurs byref Quotations cannot contain expressions that make member constraint calls, or uses of operators that implicitly resolve to a member constraint call Les quotations ne peuvent pas contenir d'expressions qui appellent des contraintes de membres ou utilisent des opérateurs qui sont implicitement résolus en appel de contrainte membre Quotations cannot contain this kind of constant Les quotations ne peuvent pas contenir ce genre de constante Quotations cannot contain this kind of pattern match Les quotations ne peuvent pas contenir ce genre de critère spécial Quotations cannot contain array pattern matching Les quotations ne peuvent pas contenir de critères spéciaux de tableau Quotations cannot contain this kind of type Les quotations ne peuvent pas contenir ce genre de type The declared type parameter '{0}' cannot be used here since the type parameter cannot be resolved at compile time Impossible d'utiliser ici le paramètre de type déclaré '{0}', car le paramètre de type ne peut pas être résolu au moment de la compilation This code is less generic than indicated by its annotations. A unit-of-measure specified using '_' has been determined to be '1', i.e. dimensionless. Consider making the code generic, or removing the use of '_'. Ce code est moins générique que ne l'indiquaient ses annotations. Une unité de mesure spécifiée à l'aide de '_' a été déterminée comme étant égale à '1', c'est-à-dire sans dimension. Rendez le code générique ou supprimez l'utilisation de '_'. Type inference problem too complicated (maximum iteration depth reached). Consider adding further type annotations. Problème d'inférence de type trop complexe (profondeur d'itération maximale atteinte). Ajoutez d'autres annotations de type. Expected arguments to an instance member Arguments attendus pour un membre d'instance This indexer expects {0} arguments but is here given {1} Cet indexeur attend {0} arguments mais en reçoit ici {1} Expecting a type supporting the operator '{0}' but given a function type. You may be missing an argument to a function. Un type prenant en charge l'opérateur '{0}' est attendu mais un type de fonction a été reçu. Il manque peut-être un argument à une fonction. Expecting a type supporting the operator '{0}' but given a tuple type Un type prenant en charge l'opérateur '{0}' est attendu, mais un type tuple a été reçu None of the types '{0}' support the operator '{1}' Aucun des types '{0}' ne prend en charge l'opérateur '{1}' The type '{0}' does not support the operator '{1}' Le type '{0}' ne prend pas en charge l'opérateur '{1}' None of the types '{0}' support the operator '{1}'. Consider opening the module 'Microsoft.FSharp.Linq.NullableOperators'. Aucun des types '{0}' ne prend en charge l'opérateur '{1}'. Envisagez d'ouvrir le module 'Microsoft.FSharp.Linq.NullableOperators'. The type '{0}' does not support the operator '{1}'. Consider opening the module 'Microsoft.FSharp.Linq.NullableOperators'. Le type '{0}' ne prend pas en charge l'opérateur '{1}'. Ouvrez le module 'Microsoft.FSharp.Linq.NullableOperators'. The type '{0}' does not support a conversion to the type '{1}' Le type '{0}' ne prend pas en charge une conversion vers le type '{1}' The type '{0}' has a method '{1}' (full name '{2}'), but the method is static Le type '{0}' a une méthode '{1}' (nom complet '{2}'), mais la méthode est statique The type '{0}' has a method '{1}' (full name '{2}'), but the method is not static Le type '{0}' a une méthode '{1}' (nom complet '{2}'), mais la méthode n'est pas statique The constraints 'struct' and 'not struct' are inconsistent Les contraintes 'struct' et 'not struct' ne sont pas cohérentes The type '{0}' does not have 'null' as a proper value Le type '{0}' n'a pas la valeur 'null' comme valeur appropriée The type '{0}' does not have 'null' as a proper value. To create a null value for a Nullable type use 'System.Nullable()'. Le type '{0}' n'a pas la valeur 'null' comme valeur appropriée. Pour créer une valeur null pour un type Nullable, utilisez 'System.Nullable()'. The type '{0}' does not support the 'comparison' constraint because it has the 'NoComparison' attribute Le type '{0}' ne prend pas en charge la contrainte 'comparison', car il a l'attribut 'NoComparison' The type '{0}' does not support the 'comparison' constraint. For example, it does not support the 'System.IComparable' interface Le type '{0}' ne prend pas en charge la contrainte 'comparison'. Par exemple, il ne prend pas en charge l'interface 'System.IComparable' The type '{0}' does not support the 'comparison' constraint because it is a record, union or struct with one or more structural element types which do not support the 'comparison' constraint. Either avoid the use of comparison with this type, or add the 'StructuralComparison' attribute to the type to determine which field type does not support comparison Le type '{0}' ne prend pas en charge la contrainte 'comparison', car il s'agit d'un enregistrement, d'une union ou d'une structure avec un ou plusieurs types d'éléments structurels qui ne prennent pas en charge la contrainte 'comparison'. Vous devez soit éviter d'utiliser la comparaison avec ce type, soit ajouter l'attribut 'StructuralComparison' au type pour identifier le type de champ qui ne prend pas en charge la comparaison The type '{0}' does not support the 'equality' constraint because it has the 'NoEquality' attribute Le type '{0}' ne prend pas en charge la contrainte 'equality', car il a l'attribut 'NoEquality' The type '{0}' does not support the 'equality' constraint because it is a function type Le type '{0}' ne prend pas en charge la contrainte 'equality', car il s'agit d'un type de fonction The type '{0}' does not support the 'equality' constraint because it is a record, union or struct with one or more structural element types which do not support the 'equality' constraint. Either avoid the use of equality with this type, or add the 'StructuralEquality' attribute to the type to determine which field type does not support equality Le type '{0}' ne prend pas en charge la contrainte 'equality', car il s'agit d'un enregistrement, d'une union ou d'une structure avec un ou plusieurs types d'éléments structurels qui ne prennent pas en charge la contrainte 'equality'. Vous devez soit éviter d'utiliser l'égalité avec ce type, soit ajouter l'attribut 'StructuralEquality' au type pour identifier le type de champ qui ne prend pas en charge l'égalité The type '{0}' is not a CLI enum type Le type '{0}' n'est pas un type enum CLI The type '{0}' has a non-standard delegate type Le type '{0}' a un type délégué non standard The type '{0}' is not a CLI delegate type Le type '{0}' n'est pas un type délégué CLI This type parameter cannot be instantiated to 'Nullable'. This is a restriction imposed in order to ensure the meaning of 'null' in some CLI languages is not confusing when used in conjunction with 'Nullable' values. Impossible d'instancier ce paramètre de type en 'Nullable'. Il s'agit d'une restriction imposée pour garantir que la signification de 'null' dans certains langages CLI n'entraîne pas de confusion lors de l'utilisation conjointe de valeurs 'Nullable'. A generic construct requires that the type '{0}' is a CLI or F# struct type Une construction générique requiert que le type '{0}' soit un type struct CLI ou F# A generic construct requires that the type '{0}' is an unmanaged type Une construction générique requiert que le type '{0}' soit de type non managé The type '{0}' is not compatible with any of the types {1}, arising from the use of a printf-style format string Le type '{0}' n'est pas compatible avec les types {1}, qui résultent de l'utilisation d'une chaîne de format de style printf A generic construct requires that the type '{0}' have reference semantics, but it does not, i.e. it is a struct Une construction générique requiert que le type '{0}' ait une sémantique de référence, mais ce n'est pas le cas, car il s'agit par exemple d'un struct A generic construct requires that the type '{0}' be non-abstract Une construction générique requiert que le type '{0}' soit non abstrait A generic construct requires that the type '{0}' have a public default constructor Une construction générique requiert que le type '{0}' ait un constructeur par défaut public Type instantiation length mismatch Incompatibilité de longueur de l'instanciation de type Optional arguments not permitted here Arguments facultatifs non autorisés ici {0} is not a static member {0} n'est pas un membre statique {0} is not an instance member {0} n'est pas un membre d'instance Argument length mismatch Incompatibilité de longueur des arguments The argument types don't match Les types des arguments ne correspondent pas This method expects a CLI 'params' parameter in this position. 'params' is a way of passing a variable number of arguments to a method in languages such as C#. Consider passing an array for this argument Cette méthode attend un paramètre CLI 'params' à cet emplacement. 'params' permet de passer un nombre variable d'arguments à une méthode dans les langages tels que C#. Passez un tableau pour cet argument The member or object constructor '{0}' is not {1} Le membre ou le constructeur d'objet '{0}' n'est pas {1} The member or object constructor '{0}' is not {1}. Private members may only be accessed from within the declaring type. Protected members may only be accessed from an extending type and cannot be accessed from inner lambda expressions. Le membre ou le constructeur d'objet '{0}' n'est pas {1}. Les membres privés ne peuvent être accessibles qu'à partir du type déclarant. Les membres protégés ne peuvent être accessibles qu'à partir d'un type d'extension et ne sont pas accessibles à partir d'expressions lambda internes. {0} is not a static method {0} n'est pas une méthode statique {0} is not an instance method {0} n'est pas une méthode d'instance The member or object constructor '{0}' has no argument or settable return property '{1}'. {2}. Le membre ou le constructeur d'objet '{0}' n'a aucun argument ou aucune propriété de retour définissable '{1}'. {2}. The object constructor '{0}' has no argument or settable return property '{1}'. {2}. Le constructeur d'objet '{0}' n'a aucun argument ou aucune propriété de retour définissable '{1}'. {2}. The required signature is {0} La signature requise est {0} The member or object constructor '{0}' requires {1} argument(s). The required signature is '{2}'. Le membre ou le constructeur d'objet '{0}' requiert {1} argument(s). La signature requise est '{2}'. The member or object constructor '{0}' requires {1} additional argument(s). The required signature is '{2}'. Le membre ou le constructeur d'objet '{0}' requiert {1} argument(s) supplémentaire(s). La signature requise est '{2}'. The member or object constructor '{0}' requires {1} argument(s). The required signature is '{2}'. Some names for missing arguments are {3}. Le membre ou le constructeur d'objet '{0}' requiert {1} argument(s). La signature requise est '{2}'. Voici certains noms des arguments manquants : {3}. The member or object constructor '{0}' requires {1} additional argument(s). The required signature is '{2}'. Some names for missing arguments are {3}. Le membre ou le constructeur d'objet '{0}' requiert {1} argument(s) supplémentaire(s). La signature requise est '{2}'. Voici certains noms des arguments manquants : {3}. The member or object constructor '{0}' requires {1} argument(s) but is here given {2} unnamed and {3} named argument(s). The required signature is '{4}'. Le membre ou le constructeur d'objet '{0}' requiert {1} argument(s) mais reçoit ici {2} argument(s) non nommé(s) et {3} argument(s) nommé(s). La signature requise est '{4}'. The member or object constructor '{0}' takes {1} argument(s) but is here given {2}. The required signature is '{3}'. Le membre ou le constructeur d'objet '{0}' accepte {1} argument(s) mais en reçoit ici {2}. La signature requise est '{3}'. The object constructor '{0}' takes {1} argument(s) but is here given {2}. The required signature is '{3}'. Le constructeur d'objet '{0}' accepte {1} argument(s), mais il en reçoit {2} ici. La signature exigée est '{3}'. The object constructor '{0}' takes {1} argument(s) but is here given {2}. The required signature is '{3}'. If some of the arguments are meant to assign values to properties, consider separating those arguments with a comma (','). Le constructeur d'objet '{0}' accepte {1} argument(s), mais il en reçoit {2} ici. La signature exigée est '{3}'. Si certains arguments sont destinés à affecter des valeurs aux propriétés, séparez ces arguments par une virgule (','). The member or object constructor '{0}' takes {1} type argument(s) but is here given {2}. The required signature is '{3}'. Le membre ou le constructeur d'objet '{0}' accepte {1} argument(s) de type mais en reçoit ici {2}. La signature requise est '{3}'. A member or object constructor '{0}' taking {1} arguments is not accessible from this code location. All accessible versions of method '{2}' take {3} arguments. Le constructeur de membre ou d'objet '{0}' acceptant {1} arguments n'est pas accessible à partir de cet emplacement du code. Toutes les versions accessibles de la méthode '{2}' acceptent {3} arguments. Incorrect generic instantiation. No {0} member named '{1}' takes {2} generic arguments. Instanciation générique incorrecte. Aucun membre {0} nommé '{1}' n'accepte {2} arguments génériques. The member or object constructor '{0}' does not take {1} argument(s). An overload was found taking {2} arguments. Le membre ou le constructeur d'objet '{0}' n'accepte pas {1} argument(s). Une surcharge acceptant {2} arguments a été trouvée. No {0} member or object constructor named '{1}' takes {2} arguments Aucun membre ou constructeur d'objet {0} nommé '{1}' n'accepte {2} arguments No {0} member or object constructor named '{1}' takes {2} arguments. Note the call to this member also provides {3} named arguments. Aucun membre ou constructeur d'objet {0} nommé '{1}' n'accepte {2} arguments. Notez que l'appel de ce membre fournit également {3} arguments nommés. No {0} member or object constructor named '{1}' takes {2} arguments. The named argument '{3}' doesn't correspond to any argument or settable return property for any overload. Aucun membre ou constructeur d'objet {0} nommé '{1}' n'accepte {2} arguments. L'argument nommé '{3}' ne correspond pas à un argument ou une propriété de retour définissable pour une surcharge. Method or object constructor '{0}' not found Méthode ou constructeur d'objet '{0}' introuvable No overloads match for method '{0}'. Aucune surcharge correspondante pour la méthode '{0}'. A unique overload for method '{0}' could not be determined based on type information prior to this program point. A type annotation may be needed. Impossible de déterminer une surcharge unique pour la méthode '{0}' basée sur des informations de type situées avant ce point du programme. Une annotation de type peut être ajoutée. Candidates:\n{0} Candidats :\n{0} Accessibility modifiers are not permitted on 'do' bindings, but '{0}' was given. Les modificateurs d'accessibilité ne sont pas autorisés sur les liaisons 'do' mais '{0}' a été spécifié. End of file in #if section begun at or after here Fin de fichier dans la section #if ayant débuté à cet emplacement ou après End of file in string begun at or before here Fin de fichier dans la chaîne ayant débuté à cet emplacement ou avant End of file in verbatim string begun at or before here Fin de fichier dans la chaîne textuelle ayant débuté à cet emplacement ou avant End of file in comment begun at or before here Fin de fichier dans le commentaire ayant débuté à cet emplacement ou avant End of file in string embedded in comment begun at or before here Fin de fichier dans la chaîne incorporée dans le commentaire ayant débuté à cet emplacement ou avant End of file in verbatim string embedded in comment begun at or before here Fin de fichier dans la chaîne textuelle incorporée dans le commentaire ayant débuté à cet emplacement ou avant End of file in IF-OCAML section begun at or before here Fin de fichier dans la section IF-OCAML ayant débuté à cet emplacement ou avant End of file in directive begun at or before here Fin de fichier dans la directive ayant débuté à cet emplacement ou avant No #endif found for #if or #else #endif introuvable pour #if ou #else Attributes have been ignored in this construct Les attributs ont été ignorés dans cette construction 'use' bindings are not permitted in primary constructors Les liaisons 'use' ne sont pas autorisées dans les constructeurs principaux 'use' bindings are not permitted in modules and are treated as 'let' bindings Les liaisons 'use' ne sont pas autorisées dans les modules et sont considérées comme des liaisons 'let' An integer for loop must use a simple identifier Un entier d'une boucle doit utiliser un identificateur simple At most one 'with' augmentation is permitted Une seule augmentation 'with' est autorisée A semicolon is not expected at this point Point-virgule inattendu à cet emplacement Unexpected end of input Fin d'entrée inattendue Accessibility modifiers are not permitted here, but '{0}' was given. Les modificateurs d'accessibilité ne sont pas autorisés ici mais '{0}' a été spécifié. Only '#' compiler directives may occur prior to the first 'namespace' declaration Seules les directives du compilateur '#' peuvent être présentes avant la première déclaration 'namespace' Accessibility modifiers should come immediately prior to the identifier naming a construct Les modificateurs d'accessibilité doivent être placés immédiatement avant l'identificateur qui nomme une construction Files should begin with either a namespace or module declaration, e.g. 'namespace SomeNamespace.SubNamespace' or 'module SomeNamespace.SomeModule', but not both. To define a module within a namespace use 'module SomeModule = ...' Les fichiers doivent commencer par un espace de noms ou une déclaration de module, par exemple 'namespace SomeNamespace.SubNamespace' ou 'module SomeNamespace.SomeModule', mais pas les deux. Pour définir un module dans un espace de noms, utilisez 'module SomeModule = ...' A module abbreviation must be a simple name, not a path Une abréviation de module doit être un nom simple et non un chemin d'accès Ignoring attributes on module abbreviation Attributs ignorés pour l'abréviation du module The '{0}' accessibility attribute is not allowed on module abbreviation. Module abbreviations are always private. L'attribut d'accessibilité '{0}' n'est pas autorisé pour l'abréviation du module. Les abréviations de module sont toujours privées. The '{0}' visibility attribute is not allowed on module abbreviation. Module abbreviations are always private. L'attribut de visibilité '{0}' n'est pas autorisé pour l'abréviation du module. Les abréviations de module sont toujours privées. Unclosed block Bloc non fermé Unmatched 'begin' or 'struct' 'begin' ou 'struct' non apparié A module name must be a simple name, not a path Un nom de module doit être un nom simple et non un chemin d'accès Unexpected empty type moduleDefn list Liste moduleDefn de type vide inattendue Attributes should be placed before 'val' Les attributs doivent être placés avant 'val' Attributes are not permitted on interface implementations Les attributs ne sont pas autorisés dans les implémentations d'interfaces Syntax error erreur de syntaxe Augmentations are not permitted on delegate type moduleDefns Les augmentations ne sont pas autorisées sur le type délégué moduleDefns Unmatched 'class', 'interface' or 'struct' 'class', 'interface' ou 'struct' non apparié A type definition requires one or more members or other declarations. If you intend to define an empty class, struct or interface, then use 'type ... = class end', 'interface end' or 'struct end'. Une définition de type requiert un ou plusieurs membres ou d'autres déclarations. Si vous envisagez de définir une classe, un struct ou une interface vide, utilisez 'type ... = class end', 'interface end' ou 'struct end'. Unmatched 'with' or badly formatted 'with' block 'with' non apparié ou format incorrect du bloc 'with' 'get', 'set' or 'get,set' required 'get', 'set' ou 'get,set' requis Only class types may take value arguments Seuls les types classe peuvent accepter des arguments de valeur Unmatched 'begin' 'begin' non apparié Invalid declaration syntax Syntaxe de déclaration non valide 'get' and/or 'set' required 'get' et/ou 'set' requis Type annotations on property getters and setters must be given after the 'get()' or 'set(v)', e.g. 'with get() : string = ...' Les annotations de type des méthodes getter et setter d'une propriété doivent être spécifiées après 'get()' ou 'set(v)', par exemple 'with get() : string = ...' A getter property is expected to be a function, e.g. 'get() = ...' or 'get(index) = ...' Une propriété de méthode getter est censée être une fonction, par exemple 'get() = ...' ou 'get(index) = ...' Multiple accessibilities given for property getter or setter Plusieurs accessibilités fournies pour la méthode getter ou setter de la propriété Property setters must be defined using 'set value = ', 'set idx value = ' or 'set (idx1,...,idxN) value = ... ' Les méthodes setter d'une propriété doivent être définies via 'set value = ', 'set idx value = ' ou 'set (idx1,...,idxN) value = ... ' Interfaces always have the same visibility as the enclosing type Les interfaces ont toujours la même visibilité que le type englobant Accessibility modifiers are not allowed on this member. Abstract slots always have the same visibility as the enclosing type. Les modificateurs d'accessibilité ne sont pas autorisés sur ce membre. Les emplacements abstraits ont toujours la même visibilité que le type englobant. Attributes are not permitted on 'inherit' declarations Les attributs ne sont pas autorisés dans les déclarations 'inherit' Accessibility modifiers are not permitted on an 'inherits' declaration Les modificateurs d'accessibilité ne sont pas autorisés sur une déclaration 'inherits' 'inherit' declarations cannot have 'as' bindings. To access members of the base class when overriding a method, the syntax 'base.SomeMember' may be used; 'base' is a keyword. Remove this 'as' binding. Les déclarations 'inherit' ne peuvent pas avoir de liaisons 'as'. Pour accéder aux membres de la classe de base lors de la substitution d'une méthode, la syntaxe 'base.SomeMember' peut être utilisée ; 'base' est un mot clé. Supprimez cette liaison 'as'. Attributes are not allowed here Les attributs ne sont pas autorisés ici Accessibility modifiers are not permitted in this position for type abbreviations Les modificateurs d'accessibilité ne sont pas autorisés à cette position pour les abréviations de type Accessibility modifiers are not permitted in this position for enum types Les modificateurs d'accessibilité ne sont pas autorisés à cette position pour les types enum All enum fields must be given values Tous les champs enum doivent recevoir des valeurs Accessibility modifiers are not permitted on inline assembly code types Les modificateurs d'accessibilité ne sont pas autorisés sur les types de codes assembleur inline Unexpected identifier: '{0}' Identificateur inattendu : '{0}' Accessibility modifiers are not permitted on union cases. Use 'type U = internal ...' or 'type U = private ...' to give an accessibility to the whole representation. Les modificateurs d'accessibilité ne sont pas autorisés sur les cas d'union. Utilisez 'type U = internal ...' ou 'type U = private ...' pour fournir une accessibilité à l'ensemble de la représentation. Accessibility modifiers are not permitted on enumeration fields Les modificateurs d'accessibilité ne sont pas autorisés sur les champs d'énumération Consider using a separate record type instead Utilisez un autre type enregistrement à la place Accessibility modifiers are not permitted on record fields. Use 'type R = internal ...' or 'type R = private ...' to give an accessibility to the whole representation. Les modificateurs d'accessibilité ne sont pas autorisés sur les champs de type enregistrement. Utilisez 'type R = internal ...' ou 'type R = private ...' pour fournir une accessibilité à l'ensemble de la représentation. The declaration form 'let ... and ...' for non-recursive bindings is not used in F# code. Consider using a sequence of 'let' bindings La forme de déclaration 'let ... and ...' pour les liaisons non récursives n'est pas utilisée dans le code F#. Utilisez une séquence de liaisons 'let' Unmatched '(' '(' non apparié Successive patterns should be separated by spaces or tupled Les modèles successifs doivent être séparés par des espaces ou être basés sur des tuples No matching 'in' found for this 'let' Impossible de trouver un 'in' correspondant pour ce 'let' Error in the return expression for this 'let'. Possible incorrect indentation. Erreur dans l'expression de retour de ce 'let'. Mise en retrait éventuellement incorrecte. The block following this '{0}' is unfinished. Every code block is an expression and must have a result. '{1}' cannot be the final code element in a block. Consider giving this block an explicit result. Le bloc qui suit ce '{0}' est inachevé. Chaque bloc de code est une expression et doit avoir un résultat. '{1}' ne peut pas être l'élément de code final d'un bloc. Donnez à ce bloc un résultat explicite. Incomplete conditional. Expected 'if <expr> then <expr>' or 'if <expr> then <expr> else <expr>'. Expression conditionnelle incomplète. Attendu 'if <expr> then <expr>' ou 'if <expr> then <expr> else <expr>'. 'assert' may not be used as a first class value. Use 'assert <expr>' instead. 'assert' ne doit pas être utilisé dans une valeur de première classe. Utilisez 'assert <expr>' à la place. Identifier expected Identificateur attendu 'in' or '=' expected 'in' ou '=' attendu The use of '->' in sequence and computation expressions is limited to the form 'for pat in expr -> expr'. Use the syntax 'for ... in ... do ... yield...' to generate elements in more complex sequence expressions. L'utilisation de '->' dans des expressions de séquence et de calcul est limitée à la forme 'for pat in expr -> expr'. Utilisez la syntaxe 'for ... in ... do ... yield...' pour générer des éléments dans des expressions de séquence plus complexes. Successive arguments should be separated by spaces or tupled, and arguments involving function or method applications should be parenthesized Les arguments successifs doivent être séparés par des espaces ou être basés sur des tuples. En outre, les arguments impliquant des applications de fonction ou de méthode doivent être mis entre parenthèses Unmatched '[' '[' non apparié Missing qualification after '.' Qualification manquante après '.' In F# code you may use 'expr.[expr]'. A type annotation may be required to indicate the first expression is an array En F#, vous pouvez utiliser 'expr.[expr]'. Une annotation de type peut être nécessaire pour indiquer que la première expression est un tableau Mismatched quotation, beginning with '{0}' Incompatibilité de quotation, qui commence par '{0}' Unmatched '{0}' '{0}' non apparié Unmatched '[|' '[|' non apparié Unmatched '{{' '{{' non apparié Field bindings must have the form 'id = expr;' Les liaisons de champs doivent avoir la forme 'id = expr;' This member is not permitted in an object implementation Ce membre n'est pas autorisé dans l'implémentation d'un objet Missing function body Corps de la fonction manquant Syntax error in labelled type argument Erreur de syntaxe dans l'argument de type étiqueté Unexpected infix operator in type expression Opérateur infixe inattendu dans l'expression de type The syntax '(typ,...,typ) ident' is not used in F# code. Consider using 'ident<typ,...,typ>' instead La syntaxe '(typ,...,typ) ident' n'est pas utilisée dans le code F#. Utilisez 'ident<typ,...,typ>' à la place Invalid literal in type Littéral non valide dans le type Unexpected infix operator in unit-of-measure expression. Legal operators are '*', '/' and '^'. Opérateur infixe inattendu dans l'expression de l'unité de mesure. Les opérateurs conformes sont '*', '/' et '^'. Unexpected integer literal in unit-of-measure expression Littéral d'entier inattendu dans l'expression de l'unité de mesure Mismatched quotation operator name, beginning with '{0}' Incompatibilité du nom d'opérateur de quotation, qui commence par '{0}' Active pattern case identifiers must begin with an uppercase letter Les identificateurs de casse du modèle actif doivent commencer par une lettre majuscule The '|' character is not permitted in active pattern case identifiers Le caractère '|' n'est pas autorisé dans des identificateurs de cas de modèle actif Denominator must not be 0 in unit-of-measure exponent La valeur de l’exposant en unité de mesure du dénominateur ne doit pas être égale à 0 No '=' symbol should follow a 'namespace' declaration Aucun symbole '=' ne doit suivre une déclaration 'namespace' The syntax 'module ... = struct .. end' is not used in F# code. Consider using 'module ... = begin .. end' La syntaxe 'module ... = struct .. end' n'est pas utilisée pour le code F#. Utilisez 'module ... = begin .. end' The syntax 'module ... : sig .. end' is not used in F# code. Consider using 'module ... = begin .. end' La syntaxe 'module ... : sig .. end' n'est pas utilisée pour le code F#. Utilisez 'module ... = begin .. end' A static field was used where an instance field is expected Un champ statique a été utilisé à l'emplacement où un champ d'instance est attendu Method '{0}' is not accessible from this code location La méthode '{0}' n'est pas accessible à partir de cet emplacement du code Implicit product of measures following / Produit implicite de mesures après / Unexpected SynMeasure.Anon SynMeasure.Anon inattendu Non-zero constants cannot have generic units. For generic zero, write 0.0<_>. Les constantes non nulles ne peuvent pas avoir d'unités génériques. Pour un zéro générique, écrivez 0.0<_>. In sequence expressions, results are generated using 'yield' Dans les expressions de séquence, les résultats sont générés à l'aide de 'yield' Unexpected big rational constant Constante rationnelle importante inattendue Units-of-measure are only supported on float, float32, decimal, and integer types. Les unités de mesure sont seulement prises en charge pour les types float, float32, decimal et integer. Unexpected Const_uint16array Const_uint16array inattendu Unexpected Const_bytearray Const_bytearray inattendu A parameter with attributes must also be given a name, e.g. '[<Attribute>] Name : Type' Un paramètre avec des attributs doit aussi avoir un nom, par ex. '[<Attribute>] Name : Type' Return values cannot have names Les valeurs de retour ne peuvent pas avoir de noms SynMemberKind.PropertyGetSet only expected in parse trees SynMemberKind.PropertyGetSet attendu uniquement dans les arborescences d'analyse Namespaces cannot contain values. Consider using a module to hold your value declarations. Les espaces de noms ne peuvent pas contenir de valeurs. Utilisez un module pour conserver vos déclarations de valeur. Namespaces cannot contain extension members except in the same file and namespace declaration group where the type is defined. Consider using a module to hold declarations of extension members. Les espaces de noms ne peuvent pas contenir de membres d'extension sauf dans le groupe de déclarations de fichiers et d'espaces de noms où le type est défini. Utilisez un module pour conserver les déclarations des membres d'extension. Multiple visibility attributes have been specified for this identifier Plusieurs attributs de visibilité ont été spécifiés pour cet identificateur Multiple visibility attributes have been specified for this identifier. 'let' bindings in classes are always private, as are any 'let' bindings inside expressions. Plusieurs attributs de visibilité ont été spécifiés pour cet identificateur. Les liaisons 'let' dans les classes sont toujours privées, à l'instar des liaisons 'let' dans les expressions. The name '({0})' should not be used as a member name. To define comparison semantics for a type, implement the 'System.IComparable' interface. If defining a static member for use from other CLI languages then use the name '{1}' instead. Le nom '({0})' ne doit pas être utilisé en tant que nom de membre. Pour définir une sémantique de comparaison pour un type, implémentez l'interface 'System.IComparable'. Si vous définissez un membre statique à utiliser à partir d'autres langages CLI, utilisez le nom '{1}' à la place. The name '({0})' should not be used as a member name. To define equality semantics for a type, override the 'Object.Equals' member. If defining a static member for use from other CLI languages then use the name '{1}' instead. Le nom '({0})' ne doit pas être utilisé en tant que nom de membre. Pour définir une sémantique d'égalité pour un type, substituez le membre 'Object.Equals'. Si vous définissez un membre statique à utiliser à partir d'autres langages CLI, utilisez le nom '{1}' à la place. The name '({0})' should not be used as a member name. If defining a static member for use from other CLI languages then use the name '{1}' instead. Le nom '({0})' ne doit pas être utilisé en tant que nom de membre. Si vous définissez un membre statique à utiliser à partir d'autres langages CLI, utilisez le nom '{1}' à la place. The name '({0})' should not be used as a member name because it is given a standard definition in the F# library over fixed types Le nom '({0})' ne doit pas être utilisé en tant que nom de membre, car il reçoit une définition standard dans la bibliothèque F# sur les types fixes The '{0}' operator should not normally be redefined. To define overloaded comparison semantics for a particular type, implement the 'System.IComparable' interface in the definition of that type. Normalement, l'opérateur '{0}' ne doit pas être redéfini. Pour définir une sémantique de comparaison surchargée pour un type particulier, implémentez l'interface 'System.IComparable' dans la définition de ce type. The '{0}' operator should not normally be redefined. To define equality semantics for a type, override the 'Object.Equals' member in the definition of that type. Normalement, l'opérateur '{0}' ne doit pas être redéfini. Pour définir une sémantique d'égalité pour un type, substituez le membre 'Object.Equals' dans la définition de ce type. The '{0}' operator should not normally be redefined. Consider using a different operator name Normalement, l'opérateur '{0}' ne doit pas être redéfini. Utilisez un autre nom d'opérateur The '{0}' operator cannot be redefined. Consider using a different operator name Impossible de redéfinir l'opérateur '{0}'. Utilisez un autre nom d'opérateur Expected module or namespace parent {0} Parent de module ou d'espace de noms attendu {0} The struct, record or union type '{0}' implements the interface 'System.IComparable' explicitly. You must apply the 'CustomComparison' attribute to the type. Le type struct, enregistrement ou union '{0}' implémente explicitement l'interface 'System.IComparable'. Vous devez appliquer l'attribut 'CustomComparison' au type. The struct, record or union type '{0}' implements the interface 'System.IComparable<_>' explicitly. You must apply the 'CustomComparison' attribute to the type, and should also provide a consistent implementation of the non-generic interface System.IComparable. Le type de struct, d'enregistrement ou d'union '{0}' implémente l'interface 'System.IComparable<_>' explicitement. Vous devez appliquer l'attribut 'CustomComparison' au type et fournir une implémentation cohérente de l'interface non générique System.IComparable. The struct, record or union type '{0}' implements the interface 'System.IStructuralComparable' explicitly. Apply the 'CustomComparison' attribute to the type. Le type struct, enregistrement ou union '{0}' implémente explicitement l'interface 'System.IStructuralComparable'. Appliquez l'attribut 'CustomComparison' au type. This record contains fields from inconsistent types Cet enregistrement contient des champs de types incohérents DLLImport stubs cannot be inlined Impossible d'utiliser des stubs DLLImport inline Structs may only bind a 'this' parameter at member declarations Les structs ne peuvent lier un paramètre 'this' que dans les déclarations de membre Unexpected expression at recursive inference point Expression inattendue au point d'inférence récursif This code is less generic than required by its annotations because the explicit type variable '{0}' could not be generalized. It was constrained to be '{1}'. Ce code est moins générique que ne l'exigent ses annotations, car il est impossible de généraliser la variable de type explicite '{0}'. Il a été contraint à être '{1}'. One or more of the explicit class or function type variables for this binding could not be generalized, because they were constrained to other types Impossible de généraliser une ou plusieurs variables de type classe ou fonction explicite pour cette liaison, car elles sont contraintes par d'autres types A generic type parameter has been used in a way that constrains it to always be '{0}' Un paramètre de type générique a été utilisé d'une façon qui le contraint à être toujours '{0}' This type parameter has been used in a way that constrains it to always be '{0}' Ce paramètre de type a été utilisé d'une façon qui le contraint à être toujours '{0}' The type parameters inferred for this value are not stable under the erasure of type abbreviations. This is due to the use of type abbreviations which drop or reorder type parameters, e.g. \n\ttype taggedInt<'a> = int or\n\ttype swap<'a,'b> = 'b * 'a.\nConsider declaring the type parameters for this value explicitly, e.g.\n\tlet f<'a,'b> ((x,y) : swap<'b,'a>) : swap<'a,'b> = (y,x). Les paramètres de type déduits pour cette valeur ne sont pas stables après l'effacement des abréviation de type. C'est parce que l'utilisation des abréviations de type supprime ou réorganise les paramètres de type, par ex. \n\ttype taggedInt<'a> = int ou\n\ttype swap<'a,'b> = 'b * 'a.\nDéclarez les paramètres de type explicitement pour cette valeur, par ex.\n\tlet f<'a,'b> ((x,y) : swap<'b,'a>) : swap<'a,'b> = (y,x). Explicit type parameters may only be used on module or member bindings Les paramètres de type explicite ne peuvent être utilisés que sur les liaisons de module ou de membre You must explicitly declare either all or no type parameters when overriding a generic abstract method Vous devez déclarer explicitement tous les paramètres de type, ou aucun d'entre eux, lors de la substitution d'une méthode abstraite générique The field labels and expected type of this record expression or pattern do not uniquely determine a corresponding record type Les étiquettes et le type attendu du champ de cette expression d'enregistrement ou ce modèle d'enregistrement ne déterminent pas de manière unique un type enregistrement correspondant The field '{0}' appears twice in this record expression or pattern Le champ '{0}' apparaît à deux reprises dans cette expression ou ce modèle d'enregistrement Unknown union case Cas d'union inconnu This code is not sufficiently generic. The type variable {0} could not be generalized because it would escape its scope. Ce code n'est pas suffisamment générique. Impossible de généraliser la variable de type {0}, car elle sort de sa portée. A property cannot have explicit type parameters. Consider using a method instead. Une propriété ne peut pas avoir de paramètres de type explicite. Utilisez une méthode à la place. A constructor cannot have explicit type parameters. Consider using a static construction method instead. Un constructeur ne peut pas avoir de paramètres de type explicite. Utilisez une méthode de construction statique à la place. This instance member needs a parameter to represent the object being invoked. Make the member static or use the notation 'member x.Member(args) = ...'. Ce membre d'instance nécessite un paramètre pour représenter l'objet appelé. Rendez le membre statique ou utilisez la notation 'member x.Member(args) = ...'. Unexpected source-level property specification in syntax tree Spécification de propriété au niveau source inattendue dans l'arborescence de syntaxe A static initializer requires an argument Un initialiseur statique requiert un argument An object constructor requires an argument Un constructeur d'objet requiert un argument This static member should not have a 'this' parameter. Consider using the notation 'member Member(args) = ...'. Ce membre statique ne doit pas avoir de paramètre 'this'. Utilisez la notation 'member Member(args) = ...'. An explicit static initializer should use the syntax 'static new(args) = expr' Un initialiseur statique explicite doit utiliser la syntaxe 'static new(args) = expr' An explicit object constructor should use the syntax 'new(args) = expr' Un constructeur d'objet explicite doit utiliser la syntaxe 'new(args) = expr' Unexpected source-level property specification Spécification de propriété au niveau source inattendue This form of object expression is not used in F#. Use 'member this.MemberName ... = ...' to define member implementations in object expressions. Cette forme d'expression d'objet n'est pas utilisée en F#. Utilisez 'member this.MemberName ... = ...' pour définir des implémentations de membres dans les expressions d'objet. Invalid declaration Déclaration non valide Attributes are not allowed within patterns Les attributs ne sont pas autorisés dans les modèles The generic function '{0}' must be given explicit type argument(s) La fonction générique '{0}' doit recevoir un ou plusieurs arguments de type explicite The method or function '{0}' should not be given explicit type argument(s) because it does not declare its type parameters explicitly La méthode ou fonction '{0}' ne doit pas recevoir d'arguments de type explicite, car elle ne déclare pas explicitement ses paramètres de type This value, type or method expects {0} type parameter(s) but was given {1} Cette valeur, ce type ou cette méthode attend {0} paramètre(s) de type mais en a reçu {1} The default, zero-initializing constructor of a struct type may only be used if all the fields of the struct type admit default initialization Le constructeur d'initialisation à zéro par défaut d'un type struct ne peut être utilisé que si tous les champs du type struct admettent l'initialisation par défaut Couldn't find Dispose on IDisposable, or it was overloaded Impossible de trouver Dispose sur IDisposable, ou il a été surchargé This value is not a literal and cannot be used in a pattern Cette valeur n'est pas un littéral. Impossible de l'utiliser dans un modèle This field is readonly Ce champ est en lecture seule Named arguments must appear after all other arguments Les arguments nommés doivent apparaître après tous les autres arguments This function value is being used to construct a delegate type whose signature includes a byref argument. You must use an explicit lambda expression taking {0} arguments. Cette valeur de fonction est utilisée pour construire un type délégué dont la signature comprend un argument byref. Vous devez utiliser une expression lambda explicite qui accepte {0} arguments. The type '{0}' is not a type whose values can be enumerated with this syntax, i.e. is not compatible with either seq<_>, IEnumerable<_> or IEnumerable and does not have a GetEnumerator method Le type '{0}' n'est pas un type dont les valeurs peuvent être énumérées avec cette syntaxe, par ex. il n'est pas compatible avec seq<_>, IEnumerable<_> ou IEnumerable et n'a pas de méthode GetEnumerator This recursive binding uses an invalid mixture of recursive forms Cette liaison récursive utilise une combinaison non valide de formes récursives This is not a valid object construction expression. Explicit object constructors must either call an alternate constructor or initialize all fields of the object and specify a call to a super class constructor. Expression de construction d'objet non valide. Les constructeurs d'objets doivent appeler un autre constructeur ou initialiser tous les champs de l'objet et spécifier un appel à un constructeur de superclasse. Invalid constraint Contrainte non valide Invalid constraint: the type used for the constraint is sealed, which means the constraint could only be satisfied by at most one solution Contrainte non valide : le type utilisé pour la contrainte est sealed, ce qui signifie que la contrainte ne peut être satisfaite que par une seule solution An 'enum' constraint must be of the form 'enum<type>' Une contrainte 'enum' doit être de la forme 'enum<type>' 'new' constraints must take one argument of type 'unit' and return the constructed type Les contraintes 'new' doivent accepter un argument de type 'unit' et retourner le type construit This property has an invalid type. Properties taking multiple indexer arguments should have types of the form 'ty1 * ty2 -> ty3'. Properties returning functions should have types of the form '(ty1 -> ty2)'. Cette propriété a un type non valide. Les propriétés qui prennent plusieurs arguments d'indexeur doivent avoir des types de la forme 'ty1 * ty2 -> ty3'. Les propriétés qui retournent des fonctions doivent avoir des types de la forme '(ty1 -> ty2)'. Expected unit-of-measure parameter, not type parameter. Explicit unit-of-measure parameters must be marked with the [<Measure>] attribute. Paramètre d'unité de mesure attendu et non un paramètre de type. Les paramètres d'unité de mesure explicites doivent être marqués avec l'attribut [<Measure>]. Expected type parameter, not unit-of-measure parameter Paramètre de type attendu à la place d'un paramètre d'unité de mesure Expected type, not unit-of-measure Type attendu à la place d'une unité de mesure Expected unit-of-measure, not type Unité de mesure attendue à la place d'un type Units-of-measure cannot be used as prefix arguments to a type. Rewrite as postfix arguments in angle brackets. Impossible d'utiliser des unités de mesure en tant qu'arguments de préfixe pour un type. Réécrivez-les en tant qu'arguments postfixés dans des crochets pointus. Unit-of-measure cannot be used in type constructor application Impossible d'utiliser l'unité de mesure dans l'application de constructeur de type This control construct may only be used if the computation expression builder defines a '{0}' method Cette construction de contrôle ne peut être utilisée que si le générateur d'expressions de calcul définit une méthode '{0}' This type has no nested types Ce type n'a aucun type imbriqué Unexpected {0} in type expression {0} inattendu dans l'expression de type Type parameter cannot be used as type constructor Impossible d'utiliser le paramètre de type en tant que constructeur de type Illegal syntax in type expression Syntaxe non conforme dans l'expression de type Anonymous unit-of-measure cannot be nested inside another unit-of-measure expression Impossible d'imbriquer une unité de mesure anonyme dans une autre expression d'unité de mesure Anonymous type variables are not permitted in this declaration Les variables de type anonyme ne sont pas autorisées dans cette déclaration Unexpected / in type / inattendu dans le type Unexpected type arguments Arguments de type inattendus Optional arguments are only permitted on type members Les arguments facultatifs ne sont autorisés que sur les membres de type Name '{0}' not bound in pattern context Nom '{0}' non lié dans le contexte du modèle Non-primitive numeric literal constants cannot be used in pattern matches because they can be mapped to multiple different types through the use of a NumericLiteral module. Consider using replacing with a variable, and use 'when <variable> = <constant>' at the end of the match clause. Les constantes littérales numériques non primitives ne peuvent pas être utilisées dans les correspondances de modèle, car elles ne peuvent pas être mappées à plusieurs types différents à l'aide d'un module NumericLiteral. Remplacez-les par une variable et utilisez 'when <variable> = <constante>' à la fin de la clause de correspondance. Type arguments cannot be specified here Impossible de spécifier des arguments de type ici Only active patterns returning exactly one result may accept arguments Seuls les modèles actifs qui retournent un seul résultat peuvent accepter des arguments Invalid argument to parameterized pattern label Argument non valide pour l'étiquette de modèle paramétrable Internal error. Invalid index into active pattern array Erreur interne. Index non valide dans le tableau du modèle actif This union case does not take arguments Ce cas d'union n'accepte pas d'arguments This union case takes one argument Ce cas d'union accepte un argument This union case expects {0} arguments in tupled form, but was given {1}. The missing field arguments may be any of:{2} Ce cas d’union attend des arguments {0} sous forme tuple, mais a reçu {1}. Les arguments de champ manquants peuvent être l’un des suivants : {2} Field '{0}' is not static Le champ '{0}' n'est pas statique This field is not a literal and cannot be used in a pattern Ce champ n'est pas un littéral. Impossible de l'utiliser dans un modèle This is not a variable, constant, active recognizer or literal Ceci n'est pas une variable, une constante, un module de reconnaissance actif ou un littéral This is not a valid pattern Modèle non valide Character range matches have been removed in F#. Consider using a 'when' pattern guard instead. Les correspondances de plages de caractères ont été supprimées de F#. Utilisez une garde par modèle 'when' à la place. Illegal pattern Modèle non conforme Syntax error - unexpected '?' symbol Erreur de syntaxe - symbole '?' inattendu Expected {0} expressions, got {1} {0} expressions attendues, {1} obtenue(s) TcExprUndelayed: delayed TcExprUndelayed : différé This expression form may only be used in sequence and computation expressions Cette forme d'expression ne peut être utilisée que dans des expressions de séquence et de calcul Invalid object expression. Objects without overrides or interfaces should use the expression form 'new Type(args)' without braces. Expression d'objet non valide. Les objets sans substitutions ou interfaces doivent utiliser la forme d'expression 'new Type(args)' sans accolades. Invalid object, sequence or record expression Expression d'objet, de séquence ou d'enregistrement non valide Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}' Expression d'enregistrement, de séquence ou de calcul non valide. Les expressions de séquence doivent avoir le format 'seq {{ ... }}' This list or array expression includes an element of the form 'if ... then ... else'. Parenthesize this expression to indicate it is an individual element of the list or array, to disambiguate this from a list generated using a sequence expression Cette expression de liste ou de tableau comprend un élément sous la forme 'if ... then ... else'. Mettez cette expression entre parenthèses pour indiquer qu'il s'agit d'un élément individuel de la liste ou du tableau, afin de lever l'ambigüité par rapport à une liste générée à l'aide d'une expression de séquence Unable to parse format string '{0}' Impossible d'analyser la chaîne de format '{0}' This list expression exceeds the maximum size for list literals. Use an array for larger literals and call Array.ToList. Cette expression de liste dépasse la taille maximale des littéraux de liste. Utilisez un tableau pour des littéraux plus importants et appelez Array.ToList. The expression form 'expr then expr' may only be used as part of an explicit object constructor La forme d'expression 'expr then expr' ne peut être utilisée que dans le cadre d'un constructeur d'objet explicite Named arguments cannot be given to member trait calls Impossible de fournir des arguments nommés aux appels de membres de trait This is not a valid name for an enumeration case Nom non valide pour un cas d'énumération This field is not mutable Ce champ n'est pas mutable This construct may only be used within list, array and sequence expressions, e.g. expressions of the form 'seq {{ ... }}', '[ ... ]' or '[| ... |]'. These use the syntax 'for ... in ... do ... yield...' to generate elements Cette construction ne peut être utilisée que dans des expressions de liste, de tableau et de séquence, par exemple des expressions sous la forme 'seq {{ ... }}', '[ ... ]' ou '[| ... |]'. Celles-ci utilisent la syntaxe 'for ... in ... do ... yield...' pour générer des éléments This construct may only be used within computation expressions. To return a value from an ordinary function simply write the expression without 'return'. Cette construction ne peut être utilisée que dans des expressions de calcul. Pour retourner une valeur à partir d'une fonction ordinaire, écrivez simplement l'expression sans 'return'. This construct may only be used within sequence or computation expressions Cette construction ne peut être utilisée que dans des expressions de calcul ou de séquence This construct may only be used within computation expressions Cette construction ne peut être utilisée que dans des expressions de calcul Incomplete expression or invalid use of indexer syntax Expression incomplète ou utilisation non valide de la syntaxe de l’indexeur The operator 'expr.[idx]' has been used on an object of indeterminate type based on information prior to this program point. Consider adding further type constraints L'opérateur 'expr.[idx]' a été utilisé sur un objet de type indéterminé basé sur des informations situées avant ce point du programme. Ajoutez des contraintes de type supplémentaires Cannot inherit from a variable type Impossible d'hériter d'un type variable Calls to object constructors on type parameters cannot be given arguments Impossible de fournir des arguments aux appels de constructeurs d'objets sur les paramètres de type The 'CompiledName' attribute cannot be used with this language element Impossible d'utiliser l'attribut 'CompiledName' avec cet élément de langage '{0}' may only be used with named types '{0}' ne peut être utilisé qu'avec des types nommés 'inherit' cannot be used on interface types. Consider implementing the interface by using 'interface ... with ... end' instead. Impossible d'utiliser 'inherit' sur les types interface. Implémentez l'interface avec 'interface ... with ... end' à la place. 'new' cannot be used on interface types. Consider using an object expression '{{ new ... with ... }}' instead. Impossible d'utiliser 'new' sur les types interface. Utilisez une expression d'objet '{{ new ... with ... }}' à la place. Instances of this type cannot be created since it has been marked abstract or not all methods have been given implementations. Consider using an object expression '{{ new ... with ... }}' instead. Impossible de créer des instances de ce type, car il est marqué comme abstract, ou toutes les méthodes n'ont pas reçu d'implémentations. Utilisez une expression d'objet '{{ new ... with ... }}' à la place. It is recommended that objects supporting the IDisposable interface are created using the syntax 'new Type(args)', rather than 'Type(args)' or 'Type' as a function value representing the constructor, to indicate that resources may be owned by the generated value Il est recommandé que les objets prenant en charge l'interface IDisposable soient créés avec la syntaxe 'new Type(args)', au lieu de 'Type(args)' ou de 'Type' comme une valeur de fonction représentant le constructeur, pour indiquer que des ressources peuvent être détenues par la valeur générée '{0}' may only be used to construct object types '{0}' ne peut être utilisé que pour construire des types d'objets Constructors for the type '{0}' must directly or indirectly call its implicit object constructor. Use a call to the implicit object constructor instead of a record expression. Les constructeurs du type '{0}' doivent directement ou indirectement appeler son constructeur d'objet implicite. Utilisez un appel au constructeur d'objet implicite à la place d'une expression d'enregistrement. The field '{0}' has been given a value, but is not present in the type '{1}' Le champ '{0}' a une valeur, mais n'est pas présent dans le type '{1}' No assignment given for field '{0}' of type '{1}' Aucune assignation spécifiée pour le champ '{0}' de type '{1}' Extraneous fields have been given values Des champs superflus ont reçu des valeurs Only overrides of abstract and virtual members may be specified in object expressions Seules les substitutions de membres abstraits et virtuels peuvent être spécifiées dans les expressions d'objet The member '{0}' does not correspond to any abstract or virtual method available to override or implement. Le membre '{0}' ne correspond à aucune méthode abstraite ou virtuelle pouvant être substituée ou implémentée. The type {0} contains the member '{1}' but it is not a virtual or abstract method that is available to override or implement. Le type {0} contient le membre '{1}', mais il ne s'agit pas d'une méthode virtuelle ou abstraite pouvant être substituée ou implémentée. The member '{0}' does not accept the correct number of arguments. {1} argument(s) are expected, but {2} were given. The required signature is '{3}'.{4} Le membre '{0}' n'accepte pas le nombre approprié d'arguments. {1} argument(s) attendu(s) mais {2} fournis. La signature nécessaire est '{3}'.{4} The member '{0}' does not accept the correct number of arguments. One overload accepts {1} arguments, but {2} were given. The required signature is '{3}'.{4} Le membre '{0}' n'accepte pas le nombre approprié d'arguments. Une surcharge accepte {1} arguments, mais {2} ont été fournis. La signature nécessaire est '{3}'.{4} A simple method name is required here Un nom de méthode simple est requis ici The types System.ValueType, System.Enum, System.Delegate, System.MulticastDelegate and System.Array cannot be used as super types in an object expression or class Impossible d'utiliser les types System.ValueType, System.Enum, System.Delegate, System.MulticastDelegate et System.Array en tant que super types dans une classe ou une expression d'objet 'new' must be used with a named type 'new' doit être utilisé avec un type nommé Cannot create an extension of a sealed type Impossible de créer une extension d'un type sealed No arguments may be given when constructing a record value Aucun argument ne peut être fourni lors de la construction d'une valeur d'enregistrement Interface implementations cannot be given on construction expressions Impossible de fournir des implémentations d'interfaces pour des expressions de construction Object construction expressions may only be used to implement constructors in class types Les expressions de construction d'objet ne peuvent être utilisées que pour implémenter des constructeurs dans les types classe Only simple bindings of the form 'id = expr' can be used in construction expressions Seules les liaisons simples sous la forme 'id = expr' peuvent être utilisées dans les expressions de construction Objects must be initialized by an object construction expression that calls an inherited object constructor and assigns a value to each field Les objets doivent être initialisés par une expression de construction d'objet qui appelle un constructeur d'objet hérité et assigne une valeur à chaque champ Expected an interface type Type interface attendu Constructor expressions for interfaces do not take arguments Les expressions de constructeur pour les interfaces n'acceptent pas d'arguments This object constructor requires arguments Ce constructeur d'objet requiert des arguments 'new' may only be used with object constructors 'new' ne peut être utilisé qu'avec des constructeurs d'objets At least one override did not correctly implement its corresponding abstract member Au moins une substitution n'a pas implémenté correctement son membre abstrait correspondant This numeric literal requires that a module '{0}' defining functions FromZero, FromOne, FromInt32, FromInt64 and FromString be in scope Ce littéral numérique requiert qu'un module '{0}' définissant les fonctions FromZero, FromOne, FromInt32, FromInt64 et FromString se trouve dans la portée Invalid record construction Construction d'enregistrement non valide The expression form {{ expr with ... }} may only be used with record types. To build object types use {{ new Type(...) with ... }} La forme d'expression {{ expr with ... }} ne peut être utilisée qu'avec des types enregistrement. Pour générer des types d'objets, utilisez {{ new Type(...) with ... }} The inherited type is not an object model type Le type hérité n'est pas un type de modèle objet Object construction expressions (i.e. record expressions with inheritance specifications) may only be used to implement constructors in object model types. Use 'new ObjectType(args)' to construct instances of object model types outside of constructors Les expressions de construction d'objet (c'est-à-dire les expressions d'enregistrement avec des spécifications d'héritage) ne peuvent être utilisées que pour implémenter des constructeurs dans les types de modèles objet. Utilisez 'new ObjectType(args)' pour construire des instances de types de modèles objet hors des constructeurs '{{ }}' is not a valid expression. Records must include at least one field. Empty sequences are specified by using Seq.empty or an empty list '[]'. '{{ }}' n'est pas une expression valide. Les enregistrements doivent inclure au moins un champ. Les séquences vides sont spécifiées via Seq.empty ou une liste vide '[]'. This type is not a record type. Values of class and struct types must be created using calls to object constructors. Ce type n'est pas un type enregistrement. Les valeurs des types classe et struct doivent être créées à l'aide d'appels à des constructeurs d'objets. This type is not a record type Ce type n'est pas un type enregistrement This construct is ambiguous as part of a computation expression. Nested expressions may be written using 'let _ = (...)' and nested computations using 'let! res = builder {{ ... }}'. Cette construction est ambiguë dans le cadre d'une expression de calcul. Les expressions imbriquées peuvent être écrites avec 'let _ = (...)' et les calculs imbriqués avec 'let! res = builder {{ ... }}'. This construct is ambiguous as part of a sequence expression. Nested expressions may be written using 'let _ = (...)' and nested sequences using 'yield! seq {{... }}'. Cette construction est ambiguë dans le cadre d'une expression de séquence. Les expressions imbriquées peuvent être écrites avec 'let _ = (...)' et les séquences imbriquées avec 'yield! seq {{... }}'. 'do!' cannot be used within sequence expressions Impossible d'utiliser 'do!' dans des expressions de séquence The use of 'let! x = coll' in sequence expressions is not permitted. Use 'for x in coll' instead. L'utilisation de 'let! x = coll' dans les expressions de séquence n'est pas autorisée. Utilisez 'for x in coll' à la place. 'try'/'with' cannot be used within sequence expressions Impossible d'utiliser 'try'/'with' dans des expressions de séquence In sequence expressions, multiple results are generated using 'yield!' Dans les expressions de séquence, les résultats multiples sont générés à l'aide de 'yield!' Invalid assignment Assignation non valide Invalid use of a type name Utilisation non valide d'un nom de type This type has no accessible object constructors Ce type n'a aucun constructeur d'objet accessible Invalid use of an interface type Utilisation non valide d'un type interface Invalid use of a delegate constructor. Use the syntax 'new Type(args)' or just 'Type(args)'. Utilisation non valide d'un constructeur délégué. Utilisez la syntaxe 'new Type(args)' ou simplement 'Type(args)'. Property '{0}' is not static La propriété '{0}' n'est pas statique Property '{0}' is not readable La propriété '{0}' n'est pas lisible This lookup cannot be used here Impossible d'utiliser cette recherche ici Property '{0}' is static La propriété '{0}' est statique Property '{0}' cannot be set Impossible de définir la propriété '{0}' Constructors must be applied to arguments and cannot be used as first-class values. If necessary use an anonymous function '(fun arg1 ... argN -> new Type(arg1,...,argN))'. Les constructeurs doivent être appliqués aux arguments et ne peuvent pas être utilisés comme des valeurs de première classe. Si nécessaire, utilisez une fonction anonyme '(fun arg1 ... argN -> new Type(arg1,...,argN))'. The syntax 'expr.id' may only be used with record labels, properties and fields La syntaxe 'expr.id' ne peut être utilisée qu'avec des étiquettes d'enregistrement, des propriétés et des champs Event '{0}' is static L'événement '{0}' est statique Event '{0}' is not static L'événement '{0}' n'est pas statique The named argument '{0}' did not match any argument or mutable property L'argument nommé '{0}' ne correspond à aucun argument, ni à aucune propriété mutable One or more of the overloads of this method has curried arguments. Consider redesigning these members to take arguments in tupled form. Une ou plusieurs des surcharges de cette méthode comporte des arguments curryfiés. Recréez ces membres pour qu'ils acceptent des arguments basés sur des tuples. The unnamed arguments do not form a prefix of the arguments of the method called Les arguments sans nom ne forment pas le préfixe des arguments de la méthode nommée Static optimization conditionals are only for use within the F# library Les conditions de l'optimisation statique sont uniquement utilisables dans la bibliothèque F# The corresponding formal argument is not optional L'argument formel correspondant n'est pas facultatif Invalid optional assignment to a property or field Assignation facultative non valide pour une propriété ou un champ A delegate constructor must be passed a single function value Une valeur de fonction unique doit être passée à un constructeur délégué A binding cannot be marked both 'use' and 'rec' Impossible de marquer une liaison à la fois 'use' et 'rec' The 'VolatileField' attribute may only be used on 'let' bindings in classes L'attribut 'VolatileField' ne peut être utilisé que sur les liaisons 'let' dans les classes Attributes are not permitted on 'let' bindings in expressions Les attributs ne sont pas autorisés sur les liaisons 'let' dans les expressions The 'DefaultValue' attribute may only be used on 'val' declarations L'attribut 'DefaultValue' ne peut être utilisé que sur les déclarations 'val' The 'ConditionalAttribute' attribute may only be used on members L'attribut 'ConditionalAttribute' ne peut être utilisé que sur des membres This is not a valid name for an active pattern Nom non valide pour un modèle actif The 'EntryPointAttribute' attribute may only be used on function definitions in modules L'attribut 'EntryPointAttribute' ne peut être utilisé que sur les définitions de fonctions dans les modules Mutable values cannot be marked 'inline' Impossible de marquer des valeurs mutables 'inline' Mutable values cannot have generic parameters Les valeurs mutables ne peuvent pas avoir de paramètres génériques Mutable function values should be written 'let mutable f = (fun args -> ...)' Les valeurs de fonction mutables doivent être écrites 'let mutable f = (fun args -> ...)' Only functions may be marked 'inline' Seules les fonctions peuvent être marquées comme 'inline' A literal value cannot be given the [<ThreadStatic>] or [<ContextStatic>] attributes Une valeur littérale ne peut pas avoir les attributs [<ThreadStatic>] ou [<ContextStatic>] A literal value cannot be marked 'mutable' Impossible de marquer une valeur littérale 'mutable' A literal value cannot be marked 'inline' Impossible de marquer une valeur littérale 'inline' Literal values cannot have generic parameters Les valeurs littérales ne peuvent pas avoir de paramètres génériques This is not a valid constant expression Expression constante non valide This type is not accessible from this code location Ce type n'est pas accessible à partir de cet emplacement du code Unexpected condition in imported assembly: failed to decode AttributeUsage attribute Condition inattendue dans l'assembly importé : impossible de décoder l'attribut AttributeUsage Unrecognized attribute target. Valid attribute targets are 'assembly', 'module', 'type', 'method', 'property', 'return', 'param', 'field', 'event', 'constructor'. Cible d'attribut non reconnue. Les cibles d'attributs valides sont 'assembly', 'module', 'type', 'method', 'property', 'return', 'param', 'field', 'event', 'constructor'. This attribute is not valid for use on this language element. Assembly attributes should be attached to a 'do ()' declaration, if necessary within an F# module. L'utilisation de cet attribut n'est pas valide sur cet élément de langage. Les attributs d'assembly doivent être attachés à une déclaration 'do ()', si nécessaire, dans un module F#. This attribute is not valid for use on this language element L'utilisation de cet attribut n'est pas valide sur cet élément de langage Optional arguments cannot be used in custom attributes Impossible d'utiliser les arguments facultatifs dans les attributs personnalisés This property cannot be set Impossible de définir cette propriété This property or field was not found on this custom attribute type Impossible de trouver cette propriété ou ce champ dans ce type d'attribut personnalisé A custom attribute must be a reference type Un attribut personnalisé doit être un type référence The number of args for a custom attribute does not match the expected number of args for the attribute constructor Le nombre d'arguments d'un attribut personnalisé ne correspond pas au nombre attendu d'arguments du constructeur d'attribut A custom attribute must invoke an object constructor Un attribut personnalisé doit appeler un constructeur d'objet Attribute expressions must be calls to object constructors Les expressions d'attribut doivent être des appels aux constructeurs d'objets This attribute cannot be used in this version of F# Impossible d'utiliser cet attribut dans cette version de F# Invalid inline specification Spécification inline non valide 'use' bindings must be of the form 'use <var> = <expr>' Les liaisons 'use' doivent être de la forme 'use <var> = <expr>' Abstract members are not permitted in an augmentation - they must be defined as part of the type itself Les membres abstraits ne sont pas autorisés dans une augmentation. Ils doivent être définis dans le cadre du type lui-même Method overrides and interface implementations are not permitted here Les substitutions de méthodes et les implémentations d'interfaces ne sont pas autorisées ici No abstract or interface member was found that corresponds to this override Impossible de trouver un membre abstrait ou membre d'interface qui corresponde à cette substitution This override takes a different number of arguments to the corresponding abstract member. The following abstract members were found:{0} Cette substitution n'accepte pas le même nombre d'arguments que le membre abstrait correspondant. Les membres abstraits suivants ont été trouvés : {0} This method already has a default implementation Cette méthode a déjà une implémentation par défaut The method implemented by this default is ambiguous La méthode implémentée par cette valeur par défaut est ambiguë No abstract property was found that corresponds to this override Impossible de trouver une propriété abstraite qui corresponde à cette substitution This property overrides or implements an abstract property but the abstract property doesn't have a corresponding {0} Cette propriété substitue ou implémente une propriété abstraite mais cette dernière n'a pas de {0} correspondant Invalid signature for set member Signature non valide pour le membre défini This new member hides the abstract member '{0}'. Rename the member or use 'override' instead. Ce nouveau membre masque le membre abstrait '{0}'. Renommez le membre ou utilisez 'override' à la place. This new member hides the abstract member '{0}' once tuples, functions, units of measure and/or provided types are erased. Rename the member or use 'override' instead. Ce nouveau membre masque le membre abstrait '{0}', une fois les tuples, fonctions, les unités de mesure et/ou les types fournis effacés. Renommez le membre ou utilisez 'override' à la place. Interfaces cannot contain definitions of static initializers Les interfaces ne peuvent pas contenir de définitions d'initialiseurs statiques Interfaces cannot contain definitions of object constructors Les interfaces ne peuvent pas contenir de définitions de constructeurs d'objets Interfaces cannot contain definitions of member overrides Les interfaces ne peuvent pas contenir de définitions de substitutions de membres Interfaces cannot contain definitions of concrete instance members. You may need to define a constructor on your type to indicate that the type is a class. Les interfaces ne peuvent pas contenir de définitions de membres d'instance concrets. Vous devrez peut-être définir un constructeur sur votre type pour indiquer que le type est une classe. Constructors cannot be specified in exception augmentations Impossible de spécifier des constructeurs dans des augmentations d'exception Structs cannot have an object constructor with no arguments. This is a restriction imposed on all CLI languages as structs automatically support a default constructor. Les structs ne peuvent pas avoir de constructeur d'objet sans arguments. Il s'agit d'une restriction imposée à tous les langages CLI, car les structs prennent automatiquement en charge un constructeur par défaut. Constructors cannot be defined for this type Impossible de définir des constructeurs pour ce type Recursive bindings that include member specifications can only occur as a direct augmentation of a type Les liaisons récursives qui incluent des spécifications de membres ne peuvent se produire qu'en tant qu'augmentation directe d'un type Only simple variable patterns can be bound in 'let rec' constructs Seuls les modèles de variable simples peuvent être liés dans les constructions 'let rec' Mutable 'let' bindings can't be recursive or defined in recursive modules or namespaces Les liaisons 'let' mutables ne peuvent pas être récursives ou définies dans des modules ou espaces de noms récursifs This member is not sufficiently generic Ce membre n'est pas suffisamment générique A declaration may only be the [<Literal>] attribute if a constant value is also given, e.g. 'val x: int = 1' Une déclaration ne peut être l'attribut [<Literal>] que si une valeur constante est aussi donnée, par exemple : « val x : int = 1 » A declaration may only be given a value in a signature if the declaration has the [<Literal>] attribute Une déclaration peut uniquement recevoir une valeur dans une signature si elle a l'attribut [<Literal>] Thread-static and context-static variables must be static and given the [<DefaultValue>] attribute to indicate that the value is initialized to the default value on each new thread Les variables static de thread et de contexte doivent être statiques et avoir l'attribut [<DefaultValue>] pour indiquer que la valeur est initialisée sur la valeur par défaut sur chaque nouveau thread Volatile fields must be marked 'mutable' and cannot be thread-static Les champs volatiles doivent être marqués comme 'mutable' et ne peuvent pas être des champs static de thread Uninitialized 'val' fields must be mutable and marked with the '[<DefaultValue>]' attribute. Consider using a 'let' binding instead of a 'val' field. Les champs 'val' non initialisés doivent être mutables et marqués avec l'attribut '[<DefaultValue>]'. Utilisez une liaison 'let' au lieu d'un champ 'val'. Static 'val' fields in types must be mutable, private and marked with the '[<DefaultValue>]' attribute. They are initialized to the 'null' or 'zero' value for their type. Consider also using a 'static let mutable' binding in a class type. Les champs 'val' statiques dans les types doivent être mutables, privés et marqués avec l'attribut '[<DefaultValue>]'. Ils sont initialisés sur la valeur 'null' ou 'zero' pour leur type. Utilisez aussi une liaison 'static let mutable' dans un type de classe. This field requires a name Ce champ requiert un nom Invalid namespace, module, type or union case name Nom d'espace de noms, de module, de type ou de cas d'union non valide Explicit type declarations for constructors must be of the form 'ty1 * ... * tyN -> resTy'. Parentheses may be required around 'resTy' Les déclarations de type explicites pour les constructeurs doivent être de la forme 'ty1 * ... * tyN -> resTy'. Des parenthèses peuvent être nécessaires autour de 'resTy' Return types of union cases must be identical to the type being defined, up to abbreviations Les types de retour des cas d'union doivent être identiques au type défini, jusqu'aux abréviations This is not a valid value for an enumeration literal Valeur non valide pour un littéral d'énumération The type '{0}' is not an interface type Le type '{0}' n'est pas un type interface Duplicate specification of an interface Spécification dupliquée d'une interface A field/val declaration is not permitted here Aucune déclaration de champ/valeur n'est autorisée ici A inheritance declaration is not permitted here Aucune déclaration d'héritage n'est autorisée ici This declaration opens the module '{0}', which is marked as 'RequireQualifiedAccess'. Adjust your code to use qualified references to the elements of the module instead, e.g. 'List.map' instead of 'map'. This change will ensure that your code is robust as new constructs are added to libraries. Cette déclaration ouvre le module '{0}', qui est marqué comme 'RequireQualifiedAccess'. Modifiez votre code pour utiliser des références qualifiées aux éléments du module à la place. Par exemple, utilisez 'List.map' au lieu de 'map'. Cette modification garantit la fiabilité de votre code au fur et à mesure de l'ajout de nouvelles constructions aux bibliothèques. This declaration opens the namespace or module '{0}' through a partially qualified path. Adjust this code to use the full path of the namespace. This change will make your code more robust as new constructs are added to the F# and CLI libraries. Cette déclaration ouvre l'espace de noms ou le module '{0}' via un chemin d'accès partiellement qualifié. Modifiez ce code pour utiliser le chemin d'accès complet de l'espace de noms. Cette modification garantit la fiabilité de votre code au fur et à mesure de l'ajout de nouvelles constructions aux bibliothèques F# et CLI. Local class bindings cannot be marked inline. Consider lifting the definition out of the class or else do not mark it as inline. Impossible de marquer les liaisons de classe locales inline. Enlevez la définition de la classe ou ne la marquez pas inline. Type abbreviations cannot have members Les abréviations de type ne peuvent pas avoir de membres As of F# 4.1, the accessibility of type abbreviations is checked at compile-time. Consider changing the accessibility of the type abbreviation. Ignoring this warning might lead to runtime errors. À partir de F# 4.1, l'accessibilité des abréviations de type est vérifiée au moment de la compilation. Changez l'accessibilité de l'abréviation de type. Si vous ignorez cet avertissement, cela risque d'entraîner des erreurs d'exécution. Enumerations cannot have members Les énumérations ne peuvent pas avoir de membres Measure declarations may have only static members Les déclarations de mesure ne peuvent avoir que des membres statiques Structs cannot contain 'do' bindings because the default constructor for structs would not execute these bindings Les structs ne peuvent pas contenir de liaisons 'do', car le constructeur par défaut des structs n'exécute pas ces liaisons Structs cannot contain value definitions because the default constructor for structs will not execute these bindings. Consider adding additional arguments to the primary constructor for the type. Les structs ne peuvent pas contenir de définitions de valeur, car le constructeur par défaut des structs n'exécute pas ces liaisons. Ajoutez des arguments supplémentaires au constructeur principal du type. Static value definitions may only be used in types with a primary constructor. Consider adding arguments to the type definition, e.g. 'type X(args) = ...'. Les définitions de valeur statiques peuvent uniquement être utilisées dans les types comportant un constructeur principal. Ajoutez des arguments à la définition de type, par exemple 'type X(args) = …'. Measure declarations may have only static members: constructors are not available Les déclarations de mesure ne peuvent avoir que des membres statiques : les constructeurs ne sont pas disponibles A member and a local class binding both have the name '{0}' Un membre et une liaison de classe locale se nomment tous les deux '{0}' Type abbreviations cannot have interface declarations Les abréviations de type ne peuvent pas avoir de déclarations d'interface Enumerations cannot have interface declarations Les énumérations ne peuvent pas avoir de déclarations d'interface This type is not an interface type Ce type n'est pas un type interface All implemented interfaces should be declared on the initial declaration of the type Toutes les interfaces implémentées doivent être déclarées dans la déclaration initiale du type A default implementation of this interface has already been added because the explicit implementation of the interface was not specified at the definition of the type Une implémentation par défaut de cette interface a déjà été ajoutée, car l'implémentation explicite de l'interface n'a pas été spécifiée lors de la définition du type This member is not permitted in an interface implementation Ce membre n'est pas autorisé dans l'implémentation d'une interface This declaration element is not permitted in an augmentation Cet élément de déclaration n'est pas autorisé dans une augmentation Types cannot contain nested type definitions Les types ne peuvent pas contenir de définitions de type imbriquées type, exception or module type, exception ou module type or module type ou module The struct, record or union type '{0}' implements the interface 'System.IStructuralEquatable' explicitly. Apply the 'CustomEquality' attribute to the type. Le type struct, enregistrement ou union '{0}' implémente explicitement l'interface 'System.IStructuralEquatable'. Appliquez l'attribut 'CustomEquality' au type. The struct, record or union type '{0}' implements the interface 'System.IEquatable<_>' explicitly. Apply the 'CustomEquality' attribute to the type and provide a consistent implementation of the non-generic override 'System.Object.Equals(obj)'. Le type de struct, d'enregistrement ou d'union '{0}' implémente l'interface 'System.IEquatable<_>' explicitement. Appliquez l'attribut 'CustomEquality' au type et fournissez une implémentation cohérente du remplacement non générique 'System.Object.Equals(obj)'. Explicit type specifications cannot be used for exception constructors Impossible d'utiliser des spécifications de type explicite pour des constructeurs d'exception Exception abbreviations should not have argument lists Les abréviations d'exceptions ne doivent pas avoir de listes d'arguments Abbreviations for Common IL exceptions cannot take arguments Les abréviations des exceptions CIL (Common Intermediate Language) ne peuvent pas accepter d'arguments Exception abbreviations must refer to existing exceptions or F# types deriving from System.Exception Les abréviations d'exceptions doivent faire référence à des exceptions existantes ou des types F# dérivant de System.Exception Abbreviations for Common IL exception types must have a matching object constructor Les abréviations des types d'exceptions CIL (Common Intermediate Language) doivent avoir un constructeur d'objet correspondant Not an exception N'est pas une exception Invalid module name Nom de module non valide Invalid type extension Extension de type non valide The attributes of this type specify multiple kinds for the type Les attributs de ce type spécifient plusieurs genres pour le type The kind of the type specified by its attributes does not match the kind implied by its definition Le genre du type spécifié par ses attributs ne correspond pas au genre impliqué par sa définition Measure definitions cannot have type parameters Les déclarations de mesure ne peuvent pas avoir de paramètres de type This type requires a definition Ce type requiert une définition This type abbreviation has one or more declared type parameters that do not appear in the type being abbreviated. Type abbreviations must use all declared type parameters in the type being abbreviated. Consider removing one or more type parameters, or use a concrete type definition that wraps an underlying type, such as 'type C<'a> = C of ...'. Cette abréviation de type a un ou plusieurs paramètres de type déclarés qui n'apparaissent pas dans le type abrégé. Les abréviations de type doivent utiliser tous les paramètres de type déclarés dans le type abrégé. Supprimez un ou plusieurs paramètres de type ou utilisez une définition de type concrète qui encapsule un type sous-jacent, par ex. 'type C<'a> = C of ...'. Structs, interfaces, enums and delegates cannot inherit from other types Les structs, interfaces, enums et délégués ne peuvent pas hériter d'autres types Types cannot inherit from multiple concrete types Les types ne peuvent pas hériter de plusieurs types concrets Records, union, abbreviations and struct types cannot have the 'AllowNullLiteral' attribute Les types enregistrement, union, abréviation et struct ne peuvent pas avoir l'attribut 'AllowNullLiteral' Types with the 'AllowNullLiteral' attribute may only inherit from or implement types which also allow the use of the null literal Les types avec l'attribut 'AllowNullLiteral' ne peuvent hériter que des types ou implémenter que les types qui autorisent également l'utilisation du littéral null Generic types cannot be given the 'StructLayout' attribute Impossible de donner aux types génériques l'attribut 'StructLayout' Only structs and classes without primary constructors may be given the 'StructLayout' attribute Seuls les structs et les classes sans constructeurs principaux peuvent recevoir l'attribut 'StructLayout' The representation of this type is hidden by the signature. It must be given an attribute such as [<Sealed>], [<Class>] or [<Interface>] to indicate the characteristics of the type. La représentation de ce type est masquée par la signature. Elle doit avoir un attribut de type [<Sealed>], [<Class>] ou [<Interface>] pour indiquer les caractéristiques du type. Only classes may be given the 'AbstractClass' attribute Seules les classes peuvent recevoir l'attribut 'AbstractClass' Only types representing units-of-measure may be given the 'Measure' attribute Seuls les types représentant des unités de mesure peuvent recevoir l'attribut 'Measure' Accessibility modifiers are not permitted on overrides or interface implementations Les modificateurs d'accessibilité ne sont pas autorisés pour les substitutions ou les implémentations d'interfaces Discriminated union types are always sealed Les types union discriminés sont toujours sealed Record types are always sealed Les types enregistrement sont toujours sealed Assembly code types are always sealed Les types de codes assembleur sont toujours sealed Struct types are always sealed Les types struct sont toujours sealed Delegate types are always sealed Les types délégués sont toujours sealed Enum types are always sealed Les types enum sont toujours sealed Interface types and delegate types cannot contain fields Les types interface et les types délégués ne peuvent pas contenir de champs Abbreviated types cannot be given the 'Sealed' attribute Impossible de donner aux types abrégés l'attribut 'Sealed' Cannot inherit a sealed type Impossible d'hériter d'un type sealed Cannot inherit from interface type. Use interface ... with instead. Impossible d'hériter du type interface. Utilisez interface ... with à la place. Struct types cannot contain abstract members Les types struct ne peuvent pas contenir de membres abstraits Interface types cannot be sealed Les types interface ne peuvent pas être sealed Delegate specifications must be of the form 'typ -> typ' Les spécifications de délégué doivent être de la forme 'typ -> typ' Delegate specifications must not be curried types. Use 'typ * ... * typ -> typ' for multi-argument delegates, and 'typ -> (typ -> typ)' for delegates returning function values. Les spécifications de délégué ne doivent pas être des types curryfiés. Utilisez 'typ * ... * typ -> typ' pour les délégués multiarguments et 'typ -> (typ -> typ)' pour les délégués qui retournent des valeurs de fonction. Literal enumerations must have type int, uint, int16, uint16, int64, uint64, byte, sbyte or char Les littéraux énumérés doivent être de type int, uint, int16, uint16, int64, uint64, byte, sbyte ou char This type definition involves an immediate cyclic reference through an abbreviation Cette définition de type implique une référence cyclique immédiate via une abréviation This type definition involves an immediate cyclic reference through a struct field or inheritance relation Cette définition de type implique une référence cyclique immédiate via un champ struct ou une relation d'héritage The syntax 'type X with ...' is reserved for augmentations. Types whose representations are hidden but which have members are now declared in signatures using 'type X = ...'. You may also need to add the '[<Sealed>] attribute to the type definition in the signature La syntaxe 'type X with ...' est réservée aux augmentations. Les types dont les représentations sont masquées, mais qui ont des membres sont maintenant déclarés dans des signatures à l'aide de 'type X = ...'. Vous pouvez avoir besoin d'ajouter l'attribut '[<Sealed>] à la définition de type dans la signature Members that extend interface, delegate or enum types must be placed in a module separate to the definition of the type. This module must either have the AutoOpen attribute or be opened explicitly by client code to bring the extension members into scope. Les membres qui étendent les types interface, délégués ou enum doivent être placés dans un module distinct de la définition du type. Ce module doit avoir l'attribut AutoOpen ou être ouvert explicitement par le code client afin de placer les membres d'extension dans la portée. One or more of the declared type parameters for this type extension have a missing or wrong type constraint not matching the original type constraints on '{0}' Un ou plusieurs des paramètres de type déclarés pour cette extension de type ont une contrainte de type manquante ou incorrecte qui ne correspond pas aux contraintes de type d'origine sur '{0}' Type definitions may only have one 'inherit' specification and it must be the first declaration Les définitions de type ne peuvent avoir qu'une spécification 'inherit' et il doit s'agir de la première déclaration 'let' and 'do' bindings must come before member and interface definitions in type definitions Les liaisons 'let' et 'do' doivent précéder les définitions de membre et d'interface dans les définitions de type This 'inherit' declaration specifies the inherited type but no arguments. Consider supplying arguments, e.g. 'inherit BaseType(args)'. Cette déclaration 'inherit' spécifie le type hérité mais aucun argument. Fournissez des arguments, par exemple 'inherit BaseType(args)'. This 'inherit' declaration has arguments, but is not in a type with a primary constructor. Consider adding arguments to your type definition, e.g. 'type X(args) = ...'. Cette déclaration 'inherit' a des arguments, mais ne figure pas dans un type avec un constructeur principal. Ajoutez des arguments à votre définition de type, par exemple 'type X(args) = …'. This definition may only be used in a type with a primary constructor. Consider adding arguments to your type definition, e.g. 'type X(args) = ...'. Cette définition ne peut être utilisée que dans un type avec un constructeur principal. Ajoutez des arguments à votre définition de type, par exemple, e.g. 'type X(args) =…'. Type abbreviations cannot have augmentations Les abréviations de type ne peuvent pas avoir d'augmentations The path '{0}' is a namespace. A module abbreviation may not abbreviate a namespace. Le chemin '{0}' est un espace de noms. Une abréviation de module ne peut pas être abrégée en espace de noms. The type '{0}' is used in an invalid way. A value prior to '{1}' has an inferred type involving '{2}', which is an invalid forward reference. Le type '{0}' est utilisé de manière incorrecte. Une valeur antérieure à '{1}' a un type déduit qui implique '{2}', qui est une référence anticipée non valide. The member '{0}' is used in an invalid way. A use of '{1}' has been inferred prior to the definition of '{2}', which is an invalid forward reference. Le membre '{0}' est utilisé de manière incorrecte. Une utilisation de '{1}' a été déduite avant la définition de '{2}'. Il s'agit d'une référence anticipée non valide. The attribute 'AutoOpen(\"{0}\")' in the assembly '{1}' did not refer to a valid module or namespace in that assembly and has been ignored L'attribut 'AutoOpen(\"{0}\")' de l'assembly '{1}' ne faisait pas référence à un module ou un espace de noms valide dans cet assembly et a été ignoré Undefined value '{0}' Valeur non définie '{0}' Label {0} not found Étiquette {0} introuvable Incorrect number of type arguments to local call Nombre incorrect d'arguments de type dans l'appel local Dynamic invocation of {0} is not supported L'appel dynamique de {0} n'est pas pris en charge Taking the address of a literal field is invalid L'acceptation de l'adresse d'un champ littéral n'est pas valide This operation involves taking the address of a value '{0}' represented using a local variable or other special representation. This is invalid. Cette opération implique l'acceptation de l'adresse d'une valeur '{0}' représentée à l'aide d'une variable locale ou de toute autre représentation spéciale. Ceci n'est pas valide. Custom marshallers cannot be specified in F# code. Consider using a C# helper function. Impossible de spécifier des marshaleurs personnalisés en F#. Utilisez une fonction d'assistance C#. The MarshalAs attribute could not be decoded Impossible de décoder l'attribut MarshalAs The signature for this external function contains type parameters. Constrain the argument and return types to indicate the types of the corresponding C function. La signature de cette fonction externe contient des paramètres de type. Appliquez une contrainte à l'argument et aux types de retour pour indiquer les types de la fonction C correspondante. The DllImport attribute could not be decoded Impossible de décoder l'attribut DllImport Literal fields cannot be set Impossible de définir les champs littéral GenSetStorage: {0} was represented as a static method but was not an appropriate lambda expression GenSetStorage : {0} a été représenté en tant que méthode statique mais n'était pas une expression lambda appropriée Mutable variables cannot escape their method Impossible d'utiliser les variables mutables en dehors de leur méthode Compiler error: unexpected unrealized value Erreur du compilateur : valeur non réalisée inattendue Main module of program is empty: nothing will happen when it is run Le module principal du programme est vide : rien ne se passera lors de son exécution This type cannot be used for a literal field Impossible d'utiliser ce type pour un champ littéral Unexpected GetSet annotation on a property Annotation GetSet inattendue pour une propriété The FieldOffset attribute could not be decoded Impossible de décoder l'attribut FieldOffset The StructLayout attribute could not be decoded Impossible de décoder l'attribut StructLayout The DefaultAugmentation attribute could not be decoded Impossible de décoder l'attribut DefaultAugmentation Reflected definitions cannot contain uses of the prefix splice operator '%' Les définitions réfléchies ne peuvent pas contenir d'utilisations de l'opérateur d'ajout de préfixe '%' Problem with codepage '{0}': {1} Problème avec la page de codes '{0}' : {1} Copyright (c) Microsoft Corporation. All Rights Reserved. Copyright (C) Microsoft Corporation. Tous droits réservés. Freely distributed under the MIT Open Source License. https://github.com/Microsoft/visualfsharp/blob/master/License.txt Distribué gratuitement sous licence Open Source du MIT. https://github.com/Microsoft/visualfsharp/blob/master/License.txt Name of the output file (Short form: -o) Nom du fichier de sortie (forme abrégée : -o) Build a console executable Générer un fichier exécutable console Build a Windows executable Générer un fichier exécutable Windows Build a library (Short form: -a) Générer une bibliothèque (forme abrégée : -a) Build a module that can be added to another assembly Générer un module qui peut être ajouté à un autre assembly Delay-sign the assembly using only the public portion of the strong name key Différer la signature de l'assembly en utilisant uniquement la partie publique de la clé de nom fort Public-sign the assembly using only the public portion of the strong name key, and mark the assembly as signed Signer publiquement l'assembly en utilisant uniquement la partie publique de la clé de nom fort, et marquer l'assembly comme signé Write the xmldoc of the assembly to the given file Écrire le xmldoc de l'assembly dans le fichier donné Specify a strong name key file Spécifier un fichier de clé de nom fort Specify a strong name key container Spécifier un conteneur de clé de nom fort Limit which platforms this code can run on: x86, x64, Arm, Arm64, Itanium, anycpu32bitpreferred, or anycpu. The default is anycpu. Limite les plateformes sur lesquelles ce code peut s'exécuter : x86, x64, Arm, Arm64, Itanium, anycpu32bitpreferred, ou anycpu. La valeur par défaut est anycpu. Only include optimization information essential for implementing inlined constructs. Inhibits cross-module inlining but improves binary compatibility. Inclure uniquement les informations d'optimisation essentielles à l'implémentation de constructions inline. Empêche l'incorporation (inlining) entre modules mais améliore la compatibilité binaire. Don't add a resource to the generated assembly containing F#-specific metadata N'ajouter aucune ressource à l'assembly généré contenant les métadonnées spécifiques F# Print the inferred interface of the assembly to a file Imprimer l'interface déduite de l'assembly dans un fichier Reference an assembly (Short form: -r) Référencer un assembly (forme abrégée : -r) Specify a Win32 resource file (.res) Spécifier un fichier de ressources Win32 (.res) Specify a Win32 manifest file Spécifier un fichier manifeste Win32 Do not include the default Win32 manifest Ne pas inclure le manifeste Win32 par défaut Embed all source files in the portable PDB file Incorporer tous les fichiers sources dans le fichier PDB portable Embed specific source files in the portable PDB file Incorporer des fichiers sources spécifiques dans le fichier PDB portable Source link information file to embed in the portable PDB file Fichier d'informations Source Link à incorporer dans le fichier PDB portable Source file is too large to embed in a portable PDB Le fichier source est trop grand pour être incorporé dans un fichier PDB portable Embed the specified managed resource Incorporer la ressource managée spécifiée Link the specified resource to this assembly where the resinfo format is <file>[,<string name>[,public|private]] Lier la ressource spécifiée à cet assembly où le format resinfo est <fichier>[,<nom de la chaîne>[,public|private]] Emit debug information (Short form: -g) Émettre les informations de débogage (forme abrégée : -g) Specify debugging type: full, portable, embedded, pdbonly. ('{0}' is the default if no debuggging type specified and enables attaching a debugger to a running program, 'portable' is a cross-platform format, 'embedded' is a cross-platform format embedded into the output file). Spécifiez le type de débogage : full, portable, embedded, pdbonly. ('{0}' est la valeur par défaut si aucun type de débogage n'est spécifié. Cette valeur permet d'attacher un débogueur à un programme en cours d'exécution, 'portable' est un format multiplateforme, 'embedded' est un format multiplateforme incorporé dans le fichier de sortie). Enable optimizations (Short form: -O) Activer les optimisations (forme abrégée : -O) Enable or disable tailcalls Activer ou désactiver les appels tail Produce a deterministic assembly (including module version GUID and timestamp) Produire un assembly déterministe (en incluant le GUID et l'horodateur de la version du module) Enable or disable cross-module optimizations Activer ou désactiver les optimisations entre modules Report all warnings as errors Signaler tous les avertissements comme des erreurs Report specific warnings as errors Signaler des avertissements spécifiques comme des erreurs Set a warning level (0-5) Définir un niveau d'avertissement (0-5) Disable specific warning messages Désactiver des messages d'avertissement déterminés Enable specific warnings that may be off by default Activer les avertissements spécifiques qui peuvent être désactivés par défaut Generate overflow checks Générer des contrôles de dépassement de capacité Define conditional compilation symbols (Short form: -d) Définir les symboles de compilation conditionnelle (forme abrégée : -d) Ignore ML compatibility warnings Ignorer les avertissements de compatibilité ML Suppress compiler copyright message Supprimer le message de copyright du compilateur Display this usage message (Short form: -?) Affiche ce message d'utilisation (forme abrégée : -?) Read response file for more options Lire le fichier réponse pour plus d'options Specify the codepage used to read source files Spécifier la page de codes utilisée pour lire les fichiers sources Output messages in UTF-8 encoding Messages de sortie au format d'encodage UTF-8 Output messages with fully qualified paths Messages de sortie avec chemins d'accès qualifiés complets Specify a directory for the include path which is used to resolve source files and assemblies (Short form: -I) Spécifier un répertoire pour le chemin d'accès Include utilisé pour résoudre les fichiers sources et les assemblys (forme abrégée : -I) Base address for the library to be built Adresse de base de la bibliothèque à générer Do not reference the default CLI assemblies by default Ne pas référencer les assemblys CLI par défaut Statically link the F# library and all referenced DLLs that depend on it into the assembly being generated Lier statiquement la bibliothèque F# et toutes les DLL référencées qui en dépendent dans l'assembly en cours de génération Statically link the given assembly and all referenced DLLs that depend on this assembly. Use an assembly name e.g. mylib, not a DLL name. Lier statiquement l'assembly donné et toutes les DLL référencées qui en dépendent. Utilisez un nom d'assembly tel que mylib au lieu d'un nom de DLL. Use a resident background compilation service to improve compiler startup times. Utilisez un service de compilation en arrière-plan résident pour améliorer les temps de démarrage du compilateur. Name the output debug file Nommer le fichier de débogage de sortie Resolve assembly references using directory-based rules rather than MSBuild resolution Résoudre les références d'assembly à l'aide des règles basées sur les répertoires au lieu de la résolution MSBuild Unrecognized target '{0}', expected 'exe', 'winexe', 'library' or 'module' Cible '{0}' non reconnue, 'exe', 'winexe', 'library' ou 'module' attendu Unrecognized debug type '{0}', expected 'pdbonly' or 'full' Type de débogage '{0}' non reconnu, 'pdbonly' ou 'full' attendu Invalid warning level '{0}' Niveau d'avertissement non valide '{0}' Short form of '{0}' Forme abrégée de '{0}' The command-line option '--cliroot' has been deprecated. Use an explicit reference to a specific copy of mscorlib.dll instead. L'option de ligne de commande '--cliroot' est déconseillée. Utilisez une référence explicite à une copie spécifique de mscorlib.dll à la place. Use to override where the compiler looks for mscorlib.dll and framework components Permet de substituer l'emplacement où le compilateur recherche mscorlib.dll et les composants .NET Framework - OUTPUT FILES - - FICHIERS DE SORTIE - - INPUT FILES - - FICHIERS D'ENTRÉE - - RESOURCES - - RESSOURCES - - CODE GENERATION - - GÉNÉRATION DE CODE - - ADVANCED - - AVANCÉ - - MISCELLANEOUS - - DIVERS - - LANGUAGE - - LANGAGE - - ERRORS AND WARNINGS - - ERREURS ET AVERTISSEMENTS - Unknown --test argument: '{0}' Inconnu --argument de test : '{0}' Unrecognized platform '{0}', valid values are 'x86', 'x64', 'Arm', 'Arm64', 'Itanium', 'anycpu32bitpreferred', and 'anycpu'. The default is anycpu. Plateforme non reconnue '{0}', les valeurs valides sont 'x86', 'x64', 'Arm', 'Arm64', 'Itanium', 'anycpu32bitpreferred' et 'anycpu'. La valeur par défaut est anycpu. The command-line option '{0}' is for test purposes only L'option de ligne de commande '{0}' ne doit servir qu'à des fins de test The command-line option '{0}' has been deprecated L'option de ligne de commande '{0}' est déconseillée The command-line option '{0}' has been deprecated. Use '{1}' instead. L'option de ligne de commande '{0}' est déconseillée. Utilisez '{1}' à la place. The command-line option '{0}' has been deprecated. HTML document generation is now part of the F# Power Pack, via the tool FsHtmlDoc.exe. L'option de ligne de commande '{0}' est déconseillée. La génération de documents HTML fait désormais partie de F# Power Pack, via l'outil FsHtmlDoc.exe. Output warning and error messages in color Générer les messages d'avertissement et d'erreur en couleur Enable high-entropy ASLR Activer la randomisation du format d'espace d'adresse d'entropie élevée Specify subsystem version of this assembly Spécifier la version du sous-système de cet assembly Specify target framework profile of this assembly. Valid values are mscorlib, netcore or netstandard. Default - mscorlib Spécifiez le profil de la version cible du .NET Framework de cet assembly. Les valeurs valides sont mscorlib, netcore et netstandard. Valeur par défaut : mscorlib Emit debug information in quotations Émettre les informations de débogage entre quotations Specify the preferred output language culture name (e.g. es-ES, ja-JP) Spécifiez le nom de culture de la langue de sortie par défaut (exemple : es-ES, ja-JP) Don't copy FSharp.Core.dll along the produced binaries Ne pas copier FSharp.Core.dll avec les fichiers binaires produits Invalid version '{0}' for '--subsystemversion'. The version must be 4.00 or greater. Version '{0}' non valide pour '--subsystemversion'. La version doit être 4.00 ou supérieure. Invalid value '{0}' for '--targetprofile', valid values are 'mscorlib', 'netcore' or 'netstandard'. Valeur non valide '{0}' pour '--targetprofile'. Les valeurs valides sont 'mscorlib', 'netcore' et 'netstandard'. Full name Nom complet and {0} other overloads et {0} autres surcharges union case cas d'union active pattern result résultat du modèle actif active recognizer module de reconnaissance actif field Champ event événement property propriété extension Extension custom operation opération personnalisée argument Argument patvar patvar namespace espace de noms module module namespace/module espace de noms/module from {0} de {0} also from {0} également de {0} generated property propriété générée generated type type généré Recursive class hierarchy in type '{0}' Hiérarchie de classes récursive dans le type '{0}' Invalid recursive reference to an abstract slot Référence récursive non valide à un emplacement abstrait The event '{0}' has a non-standard type. If this event is declared in another CLI language, you may need to access this event using the explicit {1} and {2} methods for the event. If this event is declared in F#, make the type of the event an instantiation of either 'IDelegateEvent<_>' or 'IEvent<_,_>'. L'événement '{0}' a un type non standard. Si cet événement est déclaré dans un autre langage CLI, vous pouvez avoir besoin d'y accéder à l'aide des méthodes explicites {1} et {2} pour l'événement. Si cet événement est déclaré en F#, le type de l'événement doit être une instanciation de 'IDelegateEvent<_>' ou 'IEvent<_,_>'. The type '{0}' is not accessible from this code location Le type '{0}' n'est pas accessible à partir de cet emplacement du code The union cases or fields of the type '{0}' are not accessible from this code location Les cas d'union ou champs du type '{0}' ne sont pas accessibles à partir de cet emplacement du code The value '{0}' is not accessible from this code location La valeur '{0}' n'est pas accessible à partir de cet emplacement du code The union case '{0}' is not accessible from this code location Le cas d'union '{0}' n'est pas accessible à partir de cet emplacement du code The record, struct or class field '{0}' is not accessible from this code location Le champ de type enregistrement, struct ou classe '{0}' n'est pas accessible à partir de cet emplacement du code The struct or class field '{0}' is not accessible from this code location Le champ de struct ou de classe '{0}' n'est pas accessible à partir de cet emplacement du code This construct is experimental Cette construction est expérimentale No Invoke methods found for delegate type Aucune méthode Invoke trouvée pour le type délégué More than one Invoke method found for delegate type Plusieurs méthodes Invoke trouvées pour le type délégué Delegates are not allowed to have curried signatures Les délégués ne sont pas autorisés à avoir des signatures curryfiées Unexpected Expr.TyChoose Expr.TyChoose inattendu Note: Lambda-lifting optimizations have not been applied because of the use of this local constrained generic function as a first class value. Adding type constraints may resolve this condition. Remarque : les optimisations par suppression d'expressions lambda n'ont pas été appliquées en raison de l'utilisation de cette fonction générique contrainte locale en tant que valeur de première classe. L'ajout de contraintes de type peut résoudre ce problème. Identifiers containing '@' are reserved for use in F# code generation Les identificateurs qui contiennent '@' sont réservés pour la génération de code F# The identifier '{0}' is reserved for future use by F# L'identificateur '{0}' est réservé pour un usage futur par F# Missing variable '{0}' Variable manquante '{0}' Partial active patterns may only generate one result Les modèles actifs partiels ne peuvent générer qu'un seul résultat The type '{0}' is required here and is unavailable. You must add a reference to assembly '{1}'. Le type '{0}' est requis ici et n'est pas disponible. Vous devez ajouter une référence à l'assembly '{1}'. A reference to the type '{0}' in assembly '{1}' was found, but the type could not be found in that assembly Une référence au type '{0}' a été trouvée dans l'assembly '{1}', mais le type est introuvable dans cet assembly Internal error or badly formed metadata: not enough type parameters were in scope while importing Erreur interne ou métadonnées incorrectes : nombre insuffisant de paramètres de type dans la portée lors de l'importation A reference to the DLL {0} is required by assembly {1}. The imported type {2} is located in the first assembly and could not be resolved. Une référence à la DLL {0} est requise par l'assembly {1}. Le type importé {2} se trouve dans le premier assembly et n'a pas pu être résolu. An imported assembly uses the type '{0}' but that type is not public Un assembly importé utilise le type '{0}' mais ce type n'est pas public The value '{0}' was marked inline but its implementation makes use of an internal or private function which is not sufficiently accessible La valeur '{0}' a été marquée comme inline mais son implémentation utilise une fonction interne ou privée qui n'est pas suffisamment accessible The value '{0}' was marked inline but was not bound in the optimization environment La valeur '{0}' a été marquée comme inline mais n'a pas été liée dans l'environnement d'optimisation Local value {0} not found during optimization Valeur locale {0} introuvable durant l'optimisation A value marked as 'inline' has an unexpected value Une valeur marquée comme 'inline' a une valeur inattendue A value marked as 'inline' could not be inlined Impossible d'effectuer l'incorporation (inlining) d'une valeur marquée comme 'inline' Failed to inline the value '{0}' marked 'inline', perhaps because a recursive value was marked 'inline' Impossible d'effectuer l'incorporation (inlining) de la valeur '{0}' marquée comme 'inline', peut-être en raison d'une valeur récursive marquée comme 'inline' Recursive ValValue {0} ValValue {0} récursive The indentation of this 'in' token is incorrect with respect to the corresponding 'let' La mise en retrait de ce jeton 'in' est incorrecte par rapport au 'let' correspondant Possible incorrect indentation: this token is offside of context started at position {0}. Try indenting this token further or using standard formatting conventions. Mise en retrait éventuellement incorrecte : ce jeton est situé hors du contexte qui débute à la position {0}. Essayez d'effectuer une mise en retrait supplémentaire de ce jeton ou d'utiliser des conventions de mise en forme standard. The '|' tokens separating rules of this pattern match are misaligned by one column. Consider realigning your code or using further indentation. Les jetons '|' qui séparent les règles de ce critère spécial sont décalés d'une colonne. Réalignez votre code ou effectuez une mise en retrait supplémentaire. Invalid module/expression/type Module/expression/type non valide Multiple types exist called '{0}', taking different numbers of generic parameters. Provide a type instantiation to disambiguate the type resolution, e.g. '{1}'. Il existe plusieurs types nommés '{0}' qui acceptent divers nombres de paramètres génériques. Fournissez une instanciation de type pour lever l'ambiguïté de la résolution de type. Exemple : '{1}'. The instantiation of the generic type '{0}' is missing and can't be inferred from the arguments or return type of this member. Consider providing a type instantiation when accessing this type, e.g. '{1}'. L'instanciation du type générique '{0}' est manquante. Impossible de la déduire à partir des arguments ou du type de retour de ce membre. Fournissez une instanciation de type lors de l'accès à ce type. Exemple : '{1}'. 'global' may only be used as the first name in a qualified path 'global' ne peut être utilisé que comme premier nom dans un chemin d'accès qualifié This is not a constructor or literal, or a constructor is being used incorrectly Soit il ne s'agit pas d'un constructeur ou d'un littéral, soit un constructeur est utilisé de manière incorrecte Unexpected empty long identifier Identificateur long vide inattendu The record type '{0}' does not contain a label '{1}'. Le type d'enregistrement '{0}' ne contient pas d'étiquette '{1}'. Invalid field label Étiquette de champ non valide Invalid expression '{0}' Expression non valide '{0}' No constructors are available for the type '{0}' Aucun constructeur n'est disponible pour le type '{0}' The union type for union case '{0}' was defined with the RequireQualifiedAccessAttribute. Include the name of the union type ('{1}') in the name you are using. Le type union du cas d'union '{0}' a été défini avec RequireQualifiedAccessAttribute. Incluez le nom du type union ('{1}') dans le nom que vous utilisez. The record type for the record field '{0}' was defined with the RequireQualifiedAccessAttribute. Include the name of the record type ('{1}') in the name you are using. Le type d'enregistrement du champ d'enregistrement '{0}' a été défini avec RequireQualifiedAccessAttribute. Incluez le nom du type d'enregistrement ('{1}') dans le nom que vous utilisez. Unexpected error creating debug information file '{0}' Erreur inattendue lors de la création du fichier des informations de débogage '{0}' This number is outside the allowable range for this integer type Ce nombre se trouve en dehors de la plage autorisée pour ce type d'entier '{0}' is not permitted as a character in operator names and is reserved for future use '{0}' n'est pas autorisé en tant que caractère dans les noms d'opérateurs et est réservé pour un usage futur Unexpected character '{0}' Caractère inattendu '{0}' This byte array literal contains characters that do not encode as a single byte Ce littéral de tableau d'octets contient des caractères qui ne sont pas encodés sous forme d'octet unique Identifiers followed by '{0}' are reserved for future use Les identificateurs suivis de '{0}' sont réservés pour un usage futur This number is outside the allowable range for 8-bit signed integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers signés 8 bits This number is outside the allowable range for hexadecimal 8-bit signed integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers signés 8 bits hexadécimaux This number is outside the allowable range for 8-bit unsigned integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers non signés 8 bits This number is outside the allowable range for 16-bit signed integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers signés 16 bits This number is outside the allowable range for 16-bit unsigned integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers non signés 16 bits This number is outside the allowable range for 32-bit signed integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers signés 32 bits This number is outside the allowable range for 32-bit unsigned integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers non signés 32 bits This number is outside the allowable range for 64-bit signed integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers signés 64 bits This number is outside the allowable range for 64-bit unsigned integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers non signés 64 bits This number is outside the allowable range for signed native integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers natifs signés This number is outside the allowable range for unsigned native integers Ce nombre se trouve en dehors de la plage autorisée pour les entiers natifs non signés Invalid floating point number Nombre à virgule flottante non valide This number is outside the allowable range for decimal literals Ce nombre se trouve en dehors de la plage autorisée pour les littéraux décimaux This number is outside the allowable range for 32-bit floats Ce nombre se trouve en dehors de la plage autorisée pour les valeurs float 32 bits This is not a valid numeric literal. Valid numeric literals include 1, 0x1, 0o1, 0b1, 1l (int/int32), 1u (uint/uint32), 1L (int64), 1UL (uint64), 1s (int16), 1us (uint16), 1y (int8/sbyte), 1uy (uint8/byte), 1.0 (float/double), 1.0f (float32/single), 1.0m (decimal), 1I (bigint). Il ne s’agit pas d’un littéral numérique valide. Les littéraux numériques valides incluent 1, 0x1, 0o1, 0b1, 1l (int/int32), 1u (uint/uint32), 1L (int64), 1UL (uint64), 1s (int16), 1us (uint16), 1y (int8/sbyte), 1uy (uint8/byte), 1,0 (float/double), 1,0f (float32/single), 1,0 m (décimal), 1I (bigint). This is not a valid byte literal Littéral d'octet non valide This is not a valid character literal Littéral de caractère non valide This Unicode encoding is only valid in string literals Cet encodage Unicode est uniquement valide dans les littéraux de chaîne This token is reserved for future use Ce jeton est réservé pour un usage futur TABs are not allowed in F# code unless the #indent \"off\" option is used Les tabulations ne sont pas autorisées dans le code F# sauf si l'option #indent \"off\" est utilisée Invalid line number: '{0}' Numéro de ligne non valide : '{0}' #if directive must appear as the first non-whitespace character on a line La directive #if doit être le premier caractère (autre qu'un espace blanc) d'une ligne #else has no matching #if #else n'a aucun #if correspondant #endif required for #else #endif requis pour #else #else directive must appear as the first non-whitespace character on a line La directive #else doit être le premier caractère (autre qu'un espace blanc) d'une ligne #endif has no matching #if #endif n'a aucun #if correspondant #endif directive must appear as the first non-whitespace character on a line La directive #endif doit être le premier caractère (autre qu'un espace blanc) d'une ligne #if directive should be immediately followed by an identifier La directive #if doit être immédiatement suivie d'un identificateur Syntax error. Wrong nested #endif, unexpected tokens before it. Erreur de syntaxe. Imbrication incorrecte de #endif, jetons inattendus devant. #! may only appear as the first line at the start of a file. #! ne peut se trouver que sur la première ligne au début d'un fichier. Expected single line comment or end of line Commentaire sur une seule ligne ou fin de ligne attendu Infix operator member '{0}' has no arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... Le membre opérateur infixe '{0}' n'a aucun argument. Tuple de 2 arguments attendu. Exemple : static member (+) (x,y) = ... Infix operator member '{0}' has {1} initial argument(s). Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... Le membre opérateur infixe '{0}' a 1 argument initial ou {1} arguments initiaux. Tuple de 2 arguments attendu. Exemple : static member (+) (x,y) = ... Infix operator member '{0}' has extra curried arguments. Expected a tuple of 2 arguments, e.g. static member (+) (x,y) = ... Le membre opérateur infixe '{0}' a des arguments curryfiés supplémentaires. Tuple de 2 arguments attendu. Exemple : static member (+) (x,y) = ... All record, union and struct types in FSharp.Core.dll must be explicitly labelled with 'StructuralComparison' or 'NoComparison' Tous les types enregistrement, union et struct dans FSharp.Core.dll doivent être étiquetés explicitement avec 'StructuralComparison' ou 'NoComparison' The struct, record or union type '{0}' has the 'StructuralComparison' attribute but the type parameter '{1}' does not satisfy the 'comparison' constraint. Consider adding the 'comparison' constraint to the type parameter Le type struct, enregistrement ou union '{0}' a l'attribut 'StructuralComparison' mais le paramètre de type '{1}' ne satisfait pas la contrainte 'comparison'. Ajoutez la contrainte 'comparison' au paramètre de type The struct, record or union type '{0}' has the 'StructuralComparison' attribute but the component type '{1}' does not satisfy the 'comparison' constraint Le type struct, enregistrement ou union '{0}' a l'attribut 'StructuralComparison' mais le type de composant '{1}' ne satisfait pas la contrainte 'comparison' The struct, record or union type '{0}' is not structurally comparable because the type parameter {1} does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '{2}' to clarify that the type is not comparable Le type struct, enregistrement ou union '{0}' n'est pas structurellement comparable, car le paramètre de type {1} ne satisfait pas la contrainte 'comparison'. Ajoutez l'attribut 'NoComparison' au type '{2}' pour préciser que le type n'est pas comparable The struct, record or union type '{0}' is not structurally comparable because the type '{1}' does not satisfy the 'comparison' constraint. Consider adding the 'NoComparison' attribute to the type '{2}' to clarify that the type is not comparable Le type struct, enregistrement ou union '{0}' n'est pas structurellement comparable, car le type '{1}' ne satisfait pas la contrainte 'comparison'. Ajoutez l'attribut 'NoComparison' au type '{2}' pour préciser que le type n'est pas comparable The struct, record or union type '{0}' does not support structural equality because the type parameter {1} does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '{2}' to clarify that the type does not support structural equality Le type struct, enregistrement ou union '{0}' ne prend pas en charge l'égalité structurelle, car le paramètre de type {1} ne satisfait pas la contrainte 'equality'. Ajoutez l'attribut 'NoEquality' au type '{2}' pour préciser que le type ne prend pas en charge l'égalité structurelle The struct, record or union type '{0}' does not support structural equality because the type '{1}' does not satisfy the 'equality' constraint. Consider adding the 'NoEquality' attribute to the type '{2}' to clarify that the type does not support structural equality Le type struct, enregistrement ou union '{0}' ne prend pas en charge l'égalité structurelle, car le type '{1}' ne satisfait pas la contrainte 'equality'. Ajoutez l'attribut 'NoEquality' au type '{2}' pour préciser que le type ne prend pas en charge l'égalité structurelle The struct, record or union type '{0}' has the 'StructuralEquality' attribute but the type parameter '{1}' does not satisfy the 'equality' constraint. Consider adding the 'equality' constraint to the type parameter Le type struct, enregistrement ou union '{0}' a l'attribut 'StructuralEquality' mais le paramètre de type '{1}' ne satisfait pas la contrainte 'equality'. Ajoutez la contrainte 'equality' au paramètre de type The struct, record or union type '{0}' has the 'StructuralEquality' attribute but the component type '{1}' does not satisfy the 'equality' constraint Le type struct, enregistrement ou union '{0}' a l'attribut 'StructuralEquality' mais le type de composant '{1}' ne satisfait pas la contrainte 'equality' Each argument of the primary constructor for a struct must be given a type, for example 'type S(x1:int, x2: int) = ...'. These arguments determine the fields of the struct. Chaque argument du constructeur principal d'un struct doit recevoir un type, par exemple 'type S(x1:int, x2: int) = ...'. Ces arguments déterminent les champs du struct. The value '{0}' is unused La valeur '{0}' est inutilisée The recursive object reference '{0}' is unused. The presence of a recursive object reference adds runtime initialization checks to members in this and derived types. Consider removing this recursive object reference. La référence d'objet récursive '{0}' n'est pas utilisée. La présence d'une référence d'objet récursive ajoute des vérifications de l'initialisation du runtime aux membres de ce type et des types dérivés. Supprimez cette référence d'objet récursive. A getter property may have at most one argument group Une propriété de méthode getter peut avoir au maximum un groupe d'arguments A setter property may have at most two argument groups Une propriété de méthode setter peut avoir au maximum deux groupes d'arguments Invalid property getter or setter Méthode getter ou setter de propriété non valide An indexer property must be given at least one argument Une propriété d'indexeur doit être définie avec au moins un argument This operation accesses a mutable top-level value defined in another assembly in an unsupported way. The value cannot be accessed through its address. Consider copying the expression to a mutable local, e.g. 'let mutable x = ...', and if necessary assigning the value back after the completion of the operation Cette opération accède à une valeur de niveau supérieur mutable définie dans un autre assembly d'une manière non prise en charge. Impossible d'accéder à la valeur via son adresse. Copiez l'expression dans une variable locale mutable, par exemple 'let mutable x = ...', et si nécessaire, réassignez la valeur une fois l'opération terminée Remove spaces between the type name and type parameter, e.g. \"type C<'T>\", not type \"C <'T>\". Type parameters must be placed directly adjacent to the type name. Supprimez les espaces entre le nom et le paramètre de type, par ex. \"type C<'T>\" et non \"C <'T>\". Les paramètres de type doivent être juxtaposés au nom de type. Remove spaces between the type name and type parameter, e.g. \"C<'T>\", not \"C <'T>\". Type parameters must be placed directly adjacent to the type name. Supprimez les espaces entre le nom et le paramètre de type, par ex. \"C<'T>\" et non \"C <'T>\". Les paramètres de type doivent être juxtaposés au nom de type. The use of the type syntax 'int C' and 'C <int>' is not permitted here. Consider adjusting this type to be written in the form 'C<int>' L'utilisation de la syntaxe de type 'int C' et 'C <int>' n'est pas autorisée ici. Ajustez ce type en l'écrivant de la forme 'C<int>' The module/namespace '{0}' from compilation unit '{1}' did not contain the module/namespace '{2}' Le module/l'espace de noms '{0}' de l'unité de compilation '{1}' ne contenait pas le module/l'espace de noms '{2}' The module/namespace '{0}' from compilation unit '{1}' did not contain the val '{2}' Le module/l'espace de noms '{0}' de l'unité de compilation '{1}' ne contenait pas la valeur '{2}' The module/namespace '{0}' from compilation unit '{1}' did not contain the namespace, module or type '{2}' Le module/l'espace de noms '{0}' de l'unité de compilation '{1}' ne contenait pas l'espace de noms, le module ou le type '{2}' The 'UseNullAsTrueValue' attribute flag may only be used with union types that have one nullary case and at least one non-nullary case L'indicateur d'attribut 'UseNullAsTrueValue' ne peut être utilisé qu'avec des types union qui ont un cas nullaire et au moins un cas non nullaire The parameter '{0}' was inferred to have byref type. Parameters of byref type must be given an explicit type annotation, e.g. 'x1: byref<int>'. When used, a byref parameter is implicitly dereferenced. Le type byref a été attribué au paramètre '{0}' par déduction. Les paramètres de type byref doivent recevoir une annotation de type explicite, par ex. 'x1: byref<int>'. Quand il est utilisé, un paramètre byref est implicitement déréférencé. The generic member '{0}' has been used at a non-uniform instantiation prior to this program point. Consider reordering the members so this member occurs first. Alternatively, specify the full type of the member explicitly, including argument types, return type and any additional generic parameters and constraints. Le membre générique '{0}' a été utilisé au niveau d'une instanciation non uniforme avant ce point du programme. Réorganisez les membres afin que ce membre se produise en premier. Vous pouvez également spécifier le type complet du membre de façon explicite, y compris les types d'arguments, le type de retour et d'autres paramètres et contraintes génériques. The attribute '{0}' appears in both the implementation and the signature, but the attribute arguments differ. Only the attribute from the signature will be included in the compiled code. L'attribut '{0}' est présent dans l'implémentation et dans la signature, mais les arguments de l'attribut sont différents. Seul l'attribut de la signature sera inclus dans le code compilé. Cannot call an abstract base member: '{0}' Impossible d'appeler un membre de base abstrait : '{0}' Could not resolve the ambiguity in the use of a generic construct with an 'unmanaged' constraint at or near this position Impossible de résoudre l'ambigüité liée à l'utilisation d'une construction générique avec une contrainte 'unmanaged' à cette position ou à proximité This construct is for ML compatibility. {0}. You can disable this warning by using '--mlcompatibility' or '--nowarn:62'. Cette construction est pour la compatibilité ML. {0}. Vous pouvez désactiver cet avertissement en utilisant '--mlcompatibility' ou '--nowarn:62'. The type '{0}' has been marked as having an Explicit layout, but the field '{1}' has not been marked with the 'FieldOffset' attribute Le type '{0}' a été marqué comme ayant une disposition Explicit, mais le champ '{1}' n'a pas été marqué avec l'attribut 'FieldOffset' Interfaces inherited by other interfaces should be declared using 'inherit ...' instead of 'interface ...' Les interfaces héritées d'autres interfaces doivent être déclarées avec 'inherit ...' à la place de 'interface ...' Invalid prefix operator Opérateur de préfixe non valide Invalid operator definition. Prefix operator definitions must use a valid prefix operator name. Définition d'opérateur non valide. Les définitions d'opérateur de préfixe doivent utiliser un nom d'opérateur de préfixe valide. The file extensions '.ml' and '.mli' are for ML compatibility Les extensions de fichiers '.ml' et '.mli' sont utilisées pour la compatibilité ML Consider using a file with extension '.ml' or '.mli' instead Utilisez un fichier avec l'extension '.ml' ou '.mli' à la place Active pattern '{0}' is not a function Le modèle actif '{0}' n'est pas une fonction Active pattern '{0}' has a result type containing type variables that are not determined by the input. The common cause is a when a result case is not mentioned, e.g. 'let (|A|B|) (x:int) = A x'. This can be fixed with a type constraint, e.g. 'let (|A|B|) (x:int) : Choice<int,unit> = A x' Le modèle actif '{0}' a un type de résultat contenant des variables de type non déterminées par l'entrée. Souvent, il s'agit d'un cas de résultat non mentionné, par ex. 'let (|A|B|) (x:int) = A x'. Le problème peut être corrigé avec une contrainte de type, par ex. 'let (|A|B|) (x:int) : Choice<int,unit> = A x' The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit) L'attribut FieldOffset ne peut être placé que sur des membres de types marqués avec StructLayout(LayoutKind.Explicit) Optional arguments must come at the end of the argument list, after any non-optional arguments Les arguments facultatifs doivent se trouver à la fin de la liste d'arguments, après les arguments non facultatifs Attribute 'System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes L'attribute 'System.Diagnostics.ConditionalAttribute' n'est valide que sur les méthodes ou les classes d'attributs Extension members cannot provide operator overloads. Consider defining the operator as part of the type definition instead. Les membres d'extension ne peuvent pas fournir de surcharges d'opérateur. Définissez l'opérateur comme faisant partie de la définition de type. The union case named '{0}' conflicts with the generated type '{1}' Le cas d'union nommé '{0}' est en conflit avec le type généré '{1}' ReflectedDefinitionAttribute may not be applied to an instance member on a struct type, because the instance member takes an implicit 'this' byref parameter ReflectedDefinitionAttribute ne peut pas être appliqué à un membre d'instance sur un type struct, car le membre d'instance utilise un paramètre byref 'this' implicite DLLImport bindings must be static members in a class or function definitions in a module Les liaisons DLLImport doivent être des membres statiques dans une classe ou des définitions de fonction dans un module FSharp.Core.sigdata not found alongside FSharp.Core. File expected in {0}. Consider upgrading to a more recent version of FSharp.Core, where this file is no longer be required. FSharp.Core.sigdata introuvable avec FSharp.Core. Fichier attendu dans {0}. Effectuez une mise à niveau vers une version plus récente de FSharp.Core, où ce fichier n'est plus nécessaire. File '{0}' not found alongside FSharp.Core. File expected in {1}. Consider upgrading to a more recent version of FSharp.Core, where this file is no longer be required. Fichier '{0}' introuvable avec FSharp.Core. Fichier attendu dans {1}. Effectuez une mise à niveau vers une version plus récente de FSharp.Core, où ce fichier n'est plus nécessaire. Filename '{0}' contains invalid character '{1}' Le nom de fichier '{0}' contient le caractère non valide '{1}' 'use!' bindings must be of the form 'use! <var> = <expr>' Les liaisons 'use!' doivent être de la forme 'use! <var> = <expr>' Inner generic functions are not permitted in quoted expressions. Consider adding some type constraints until this function is no longer generic. Les fonctions génériques internes ne sont pas autorisées dans les expressions quotées. Ajoutez des contraintes de type jusqu'à ce que cette fonction ne soit plus générique. The type '{0}' is not a valid enumerator type , i.e. does not have a 'MoveNext()' method returning a bool, and a 'Current' property Le type '{0}' n'est pas un type d'énumérateur valide, c-à-d qu'il n'a pas de méthode 'MoveNext()' qui retourne une valeur booléenne, ni de propriété 'Current' End of file in triple-quote string begun at or before here La fin du fichier dans une chaîne à guillemets triples a commencé ici ou avant ici End of file in triple-quote string embedded in comment begun at or before here La fin du fichier dans la chaîne à guillemets triples incorporée dans un commentaire a commencé ici ou avant ici This type test or downcast will ignore the unit-of-measure '{0}' Ce test de type ou ce cast d'une classe de base va ignorer l'unité de mesure '{0}' Expected type argument or static argument Argument de type ou argument statique attendu Unmatched '<'. Expected closing '>' '<' sans correspondance. '>' fermant attendu Unexpected quotation operator '<@' in type definition. If you intend to pass a verbatim string as a static argument to a type provider, put a space between the '<' and '@' characters. Opérateur de citation inattendu '<@' dans la définition de type. Si vous voulez passer une chaîne textuelle comme argument statique à un fournisseur de type, insérez un espace entre les caractères '<' et '@'. Attempted to parse this as an operator name, but failed La tentative d'analyse de cet élément en tant que nom d'opérateur a échoué \U{0} is not a valid Unicode character escape sequence \U{0} n'est pas une séquence d'échappement de caractères Unicode valide '{0}' must be applied to an argument of type '{1}', but has been applied to an argument of type '{2}' '{0}' doit être appliqué à un argument de type '{1}', mais il a été appliqué à un argument de type '{2}' '{0}' can only be applied to optional arguments '{0}' peut uniquement être appliqué à des arguments facultatifs The specified .NET Framework version '{0}' is not supported. Please specify a value from the enumeration Microsoft.Build.Utilities.TargetDotNetFrameworkVersion. La version spécifiée du .NET Framework ('{0}') n'est pas prise en charge. Spécifiez une valeur issue de l'énumération Microsoft.Build.Utilities.TargetDotNetFrameworkVersion. Invalid Magic value in CLR Header Valeur magique non valide dans l'en-tête CLR Bad image format Format d'image incorrect Private key expected Clé privée attendue RSA key expected Clé RSA attendue Invalid bit Length Longueur de bit non valide Invalid RSAParameters structure - '{{0}}' expected Structure RSAParameters non valide - '{{0}}' attendu Invalid algId - 'Exponent' expected algId non valide - 'Exponent' attendu Invalid signature size Taille de signature non valide No signature directory Aucun répertoire de signature Invalid Public Key blob Objet blob de clé publique non valide Exiting - too many errors Fermeture en cours : trop d'erreurs The documentation file has no .xml suffix Le fichier de documentation n'a pas de suffixe .xml No implementation files specified Aucun fichier d'implémentation n'a été spécifié The attribute {0} specified version '{1}', but this value is invalid and has been ignored L'attribut {0} a spécifié la version '{1}', mais cette valeur est non valide et a été ignorée Conflicting options specified: 'win32manifest' and 'win32res'. Only one of these can be used. Options conflictuelles spécifiées : 'win32manifest' et 'win32res'. Seule l'une de ces options peut être utilisée. The code in assembly '{0}' makes uses of quotation literals. Static linking may not include components that make use of quotation literals unless all assemblies are compiled with at least F# 4.0. Le code dans l'assembly '{0}' utilise des littéraux de citation. La liaison statique risque de ne pas inclure les composants qui utilisent des littéraux de citation, sauf si tous les assemblys sont compilés avec au moins F# 4.0. Code in this assembly makes uses of quotation literals. Static linking may not include components that make use of quotation literals unless all assemblies are compiled with at least F# 4.0. Le code dans cet assembly utilise des littéraux de citation. La liaison statique risque de ne pas inclure les composants qui utilisent des littéraux de citation, sauf si tous les assemblys sont compilés avec au moins F# 4.0. Static linking may not include a .EXE La liaison statique ne peut pas inclure de fichier .EXE Static linking may not include a mixed managed/unmanaged DLL La liaison statique ne peut pas inclure une DLL mixte managée/non managée Ignoring mixed managed/unmanaged assembly '{0}' during static linking L'assembly mixte managé/non managé '{0}' est ignoré lors de la liaison statique Assembly '{0}' was referenced transitively and the assembly could not be resolved automatically. Static linking will assume this DLL has no dependencies on the F# library or other statically linked DLLs. Consider adding an explicit reference to this DLL. L'assembly '{0}' a été référencé transitivement et n'a pas pu être résolu automatiquement. La liaison statique suppose que cette DLL n'a pas de dépendances par rapport à la bibliothèque F# ou toute autre DLL liée de manière statique. Ajoutez une référence explicite à cette DLL. Assembly '{0}' not found in dependency set of target binary. Statically linked roots should be specified using an assembly name, without a DLL or EXE extension. If this assembly was referenced explicitly then it is possible the assembly was not actually required by the generated binary, in which case it should not be statically linked. L'assembly '{0}' est introuvable dans le jeu de dépendances du fichier binaire cible. Les racines liées de manière statique doivent être spécifiées à l'aide d'un nom d'assembly, sans extension DLL ou EXE. Si cet assembly a été référencé explicitement, il est possible qu'il n'ait pas été réellement requis par le fichier binaire généré. Dans ce cas, il ne doit pas être lié de manière statique. The key file '{0}' could not be opened Impossible d'ouvrir le fichier de clé '{0}' A problem occurred writing the binary '{0}': {1} Un problème s'est produit lors de l'écriture du fichier binaire '{0}' : {1} The 'AssemblyVersionAttribute' has been ignored because a version was given using a command line option 'AssemblyVersionAttribute' a été ignoré, car une version a été indiquée à l'aide d'une option en ligne de commande Error emitting 'System.Reflection.AssemblyCultureAttribute' attribute -- 'Executables cannot be satellite assemblies, Culture should always be empty' Erreur lors de l'émission de l'attribut 'System.Reflection.AssemblyCultureAttribute' -- Les exécutables ne peuvent pas être des assemblys satellites. La culture doit toujours être vide Option '--delaysign' overrides attribute 'System.Reflection.AssemblyDelaySignAttribute' given in a source file or added module L'option '--delaysign' remplace l'attribut 'System.Reflection.AssemblyDelaySignAttribute' fourni dans un fichier source ou un module ajouté Option '--keyfile' overrides attribute 'System.Reflection.AssemblyKeyFileAttribute' given in a source file or added module L'option '--keyfile' remplace l'attribut 'System.Reflection.AssemblyKeyFileAttribute' fourni dans un fichier source ou un module ajouté Option '--keycontainer' overrides attribute 'System.Reflection.AssemblyNameAttribute' given in a source file or added module L'option '--keycontainer' remplace l'attribut 'System.Reflection.AssemblyNameAttribute' fourni dans un fichier source ou un module ajouté The assembly '{0}' is listed on the command line. Assemblies should be referenced using a command line flag such as '-r'. L'assembly '{0}' est répertorié sur la ligne de commande. Les assemblys doivent être référencés à l'aide d'un indicateur de ligne de commande, tel que '-r'. The resident compilation service was not used because a problem occured in communicating with the server. Le service de compilation résident n'a pas été utilisé en raison d'un problème lors de la communication avec le serveur. Problem with filename '{0}': Illegal characters in path. Problème avec le nom de fichier '{0}' : caractères non valides dans le chemin. Passing a .resx file ({0}) as a source file to the compiler is deprecated. Use resgen.exe to transform the .resx file into a .resources file to pass as a --resource option. If you are using MSBuild, this can be done via an <EmbeddedResource> item in the .fsproj project file. Le passage d'un fichier .resx ({0}) comme fichier source au compilateur est déprécié. Utilisez resgen.exe pour transformer le fichier .resx en fichier .resources à passer comme option --resource. Si vous utilisez MSBuild, vous pouvez le faire avec un élément <EmbeddedResource> dans le fichier projet .fsproj. Static linking may not be used on an assembly referencing mscorlib (e.g. a .NET Framework assembly) when generating an assembly that references System.Runtime (e.g. a .NET Core or Portable assembly). Les liens statiques ne doivent pas être utilisés sur un assembly qui référence mscorlib (par ex., un assembly .NET Framework) pendant la génération d'un assembly qui référence System.Runtime (par ex., un assembly .NET Core ou portable). An {0} specified version '{1}', but this value is a wildcard, and you have requested a deterministic build, these are in conflict. {0} a spécifié la version '{1}', mais cette valeur est un caractère générique, et comme vous avez demandé une build déterministe, il existe un conflit. Character '{0}' is not allowed in provided namespace name '{1}' Le caractère '{0}' n'est pas autorisé dans le nom d'espace de noms fourni '{1}' The provided type '{0}' returned a member with a null or empty member name Le type fourni '{0}' a retourné un membre avec un nom de membre Null ou vide The provided type '{0}' returned a null member Le type fourni '{0}' a retourné un membre Null The provided type '{0}' member info '{1}' has null declaring type Les infos de membre '{1}' du type fourni '{0}' ont un type déclarant Null The provided type '{0}' has member '{1}' which has declaring type '{2}'. Expected declaring type to be the same as provided type. Le type fourni '{0}' a un membre '{1}' de type déclarant '{2}'. Le type déclarant attendu est le même que le type fourni. Referenced assembly '{0}' has assembly level attribute '{1}' but no public type provider classes were found L'assembly référencé '{0}' a un attribut de niveau assembly '{1}', mais aucune classe de fournisseur de type publique n'a été trouvée Type '{0}' from type provider '{1}' has an empty namespace. Use 'null' for the global namespace. Le type '{0}' du fournisseur de type '{1}' a un espace de noms vide. Utilisez 'null' pour l'espace de noms global. Empty namespace found from the type provider '{0}'. Use 'null' for the global namespace. Un nom d'espace vide a été trouvé par le fournisseur de type '{0}'. Utilisez 'null' pour l'espace de noms global. Provided type '{0}' has 'IsGenericType' as true, but generic types are not supported. 'IsGenericType' a la valeur True pour le type fourni '{0}', mais les types génériques ne sont pas pris en charge. Provided type '{0}' has 'IsArray' as true, but array types are not supported. 'IsArray' a la valeur True pour le type fourni '{0}', mais les types de tableau ne sont pas pris en charge. Invalid member '{0}' on provided type '{1}'. Provided type members must be public, and not be generic, virtual, or abstract. Membre '{0}' non valide sur le type fourni '{1}'. Les membres de type fourni doivent être publics et non pas génériques, virtuels ou abstraits. Invalid member '{0}' on provided type '{1}'. Only properties, methods and constructors are allowed Membre non valide '{0}' sur le type fourni '{1}'. Seuls les propriétés, les méthodes et les constructeurs sont autorisés Property '{0}' on provided type '{1}' has CanRead=true but there was no value from GetGetMethod() La propriété '{0}' sur le type fourni '{1}' a CanRead=true, mais aucune valeur n'a été retournée par GetGetMethod() Property '{0}' on provided type '{1}' has CanRead=false but GetGetMethod() returned a method La propriété '{0}' sur le type fourni '{1}' a CanRead=false, mais GetGetMethod() a retourné une méthode Property '{0}' on provided type '{1}' has CanWrite=true but there was no value from GetSetMethod() La propriété '{0}' sur le type fourni '{1}' a CanWrite=true, mais aucune valeur n'a été retournée par GetSetMethod() Property '{0}' on provided type '{1}' has CanWrite=false but GetSetMethod() returned a method La propriété '{0}' sur le type fourni '{1}' a CanWrite=false, mais GetSetMethod() a retourné une méthode One or more errors seen during provided type setup Une ou plusieurs erreurs se sont produites pendant la configuration du type fourni Unexpected exception from provided type '{0}' member '{1}': {2} Exception inattendue levée par le type fourni '{0}', membre '{1}' : {2} Unsupported constant type '{0}'. Quotations provided by type providers can only contain simple constants. The implementation of the type provider may need to be adjusted by moving a value declared outside a provided quotation literal to be a 'let' binding inside the quotation literal. Type de constante '{0}' non pris en charge. Les quotations fournies par les fournisseurs de type peuvent uniquement contenir des constantes simples. L'implémentation du fournisseur de type peut nécessiter un ajustement consistant à remplacer une valeur déclarée en dehors d'un littéral de quotation fourni par une liaison 'let' au sein du littéral de quotation. Unsupported expression '{0}' from type provider. If you are the author of this type provider, consider adjusting it to provide a different provided expression. Expression '{0}' non prise en charge retournée par le fournisseur de type. Si vous êtes l'auteur de ce fournisseur de type, envisagez de l'ajuster pour présenter une expression fournie différente. Expected provided type named '{0}' but provided type has 'Name' with value '{1}' Un type fourni nommé '{0}' était attendu, mais 'Name' a la valeur '{1}' pour le type fourni Event '{0}' on provided type '{1}' has no value from GetAddMethod() L'événement '{0}' sur le type fourni '{1}' n'a pas de valeur de GetAddMethod() Event '{0}' on provided type '{1}' has no value from GetRemoveMethod() L'événement '{0}' sur le type fourni '{1}' n'a pas de valeur de GetRemoveMethod() Assembly attribute '{0}' refers to a designer assembly '{1}' which cannot be loaded from path '{2}'. The exception reported was: {3} - {4} L'attribut d'assembly '{0}' fait référence à un assembly de concepteur '{1}' qui ne peut pas être chargé à partir du chemin '{2}'. Exception signalée : {3} - {4} The type provider does not have a valid constructor. A constructor taking either no arguments or one argument of type 'TypeProviderConfig' was expected. Le fournisseur de type n'a pas de constructeur valide. Un constructeur sans argument ou prenant un argument de type 'TypeProviderConfig' était attendu. The type provider '{0}' reported an error: {1} Le fournisseur de type '{0}' a signalé une erreur : {1} The type provider '{0}' used an invalid parameter in the ParameterExpression: {1} Le fournisseur de type '{0}' a utilisé un paramètre non valide dans ParameterExpression : {1} The type provider '{0}' provided a method with a name '{1}' and metadata token '{2}', which is not reported among its methods of its declaring type '{3}' Le fournisseur de type '{0}' a fourni une méthode avec un nom '{1}' et un jeton de métadonnées '{2}' qui ne figure pas parmi ses méthodes du type déclarant '{3}' The type provider '{0}' provided a constructor which is not reported among the constructors of its declaring type '{1}' Le fournisseur de type '{0}' a fourni un constructeur qui ne figure pas parmi les constructeurs de son type déclarant ' '{1}' A direct reference to the generated type '{0}' is not permitted. Instead, use a type definition, e.g. 'type TypeAlias = <path>'. This indicates that a type provider adds generated types to your assembly. Une référence directe au type généré '{0}' n'est pas autorisée. Utilisez plutôt une définition de type, par ex. 'type TypeAlias = <chemin>'. Cela indique qu'un fournisseur de type ajoute des types générés à votre assembly. Expected provided type with path '{0}' but provided type has path '{1}' Un type fourni utilisant le chemin '{0}' était attendu, mais le type fourni utilise le chemin '{1}' Unexpected 'null' return value from provided type '{0}' member '{1}' Valeur 'null' inattendue retournée par le type fourni '{0}', membre '{1}' Unexpected exception from member '{0}' of provided type '{1}' member '{2}': {3} Exception inattendue levée par le membre '{0}' du type fourni '{1}', membre '{2}' : {3} Nested provided types do not take static arguments or generic parameters Les types fournis imbriqués ne prennent pas d'arguments statiques ni de paramètres génériques Invalid static argument to provided type. Expected an argument of kind '{0}'. L'argument statique transmis au type fourni n'est pas valide. Un argument du genre '{0}' était attendu. An error occured applying the static arguments to a provided type Une erreur s'est produite lors de l'application des arguments statiques à un type fourni Unknown static argument kind '{0}' when resolving a reference to a provided type or method '{1}' Genre d'argument statique inconnu '{0}' durant la résolution d'une référence à un type ou une méthode fournie '{1}' invalid namespace for provided type espace de noms non valide pour le type fourni invalid full name for provided type nom complet non valide pour le type fourni The type provider returned 'null', which is not a valid return value from '{0}' Le fournisseur de type a retourné 'null', qui n'est pas une valeur de retour valide de '{0}' The type provider constructor has thrown an exception: {0} Le constructeur du fournisseur de type a levé une exception : {0} Type provider '{0}' returned null from GetInvokerExpression. Le fournisseur de type '{0}' a retourné Null de GetInvokerExpression. The type provider '{0}' returned an invalid type from 'ApplyStaticArguments'. A type with name '{1}' was expected, but a type with name '{2}' was returned. Le fournisseur de type '{0}' a retourné un type non valide de 'ApplyStaticArguments'. Un type nommé '{1}' était attendu, mais un type nommé '{2}' a été retourné. The type provider '{0}' returned an invalid method from 'ApplyStaticArgumentsForMethod'. A method with name '{1}' was expected, but a method with name '{2}' was returned. Le fournisseur de type '{0}' a retourné une méthode non valide à partir de 'ApplyStaticArgumentsForMethod'. La méthode nommée '{1}' était attendue, mais la méthode nommée '{2}' a été retournée. This type test or downcast will erase the provided type '{0}' to the type '{1}' Ce test de type ou ce cast d'une classe de base va effacer le type fourni '{0}' et le remplacer par le type '{1}' This downcast will erase the provided type '{0}' to the type '{1}'. Ce cast d'une classe de base va effacer le type fourni '{0}' et le remplacer par le type '{1}'. This type test with a provided type '{0}' is not allowed because this provided type will be erased to '{1}' at runtime. Ce test de type avec un type fourni '{0}' n'est pas autorisé, car ce type fourni sera effacé et remplacé par '{1}' au moment de l'exécution. Cannot inherit from erased provided type Impossible d'hériter d'un type fourni effacé Assembly '{0}' hase TypeProviderAssembly attribute with invalid value '{1}'. The value should be a valid assembly name L'assembly '{0}' a un attribut TypeProviderAssembly comportant la valeur non valide '{1}'. La valeur doit être un nom d'assembly valide Invalid member name. Members may not have name '.ctor' or '.cctor' Nom de membre non valide. Les membres ne peuvent pas être appelés '.ctor' ou '.cctor' The function or member '{0}' is used in a way that requires further type annotations at its definition to ensure consistency of inferred types. The inferred signature is '{1}'. La fonction ou le membre '{0}' est utilisé d'une manière qui nécessite d'autres annotations de type au niveau de sa définition pour garantir la cohérence des types déduits. La signature déduite est '{1}'. The number of type arguments did not match: '{0}' given, '{1}' expected. This may be related to a previously reported error. Le nombre d'arguments de type ne correspond pas : '{0}' fournis, '{1}' attendus. Ceci peut-être dû à une erreur signalée précédemment. Cannot override inherited member '{0}' because it is sealed Impossible de remplacer le membre hérité '{0}', car il est sealed The type provider '{0}' reported an error in the context of provided type '{1}', member '{2}'. The error: {3} Le fournisseur de type '{0}' a signalé une erreur dans le contexte du type fourni '{1}', membre '{2}'. Erreur : {3} An exception occurred when accessing the '{0}' of a provided type: {1} Une exception s'est produite lors de l'accès au '{0}' d'un type fourni : {1} The '{0}' of a provided type was null or empty. Le '{0}' d'un type fourni était Null ou vide. Character '{0}' is not allowed in provided type name '{1}' Le caractère '{0}' n'est pas autorisé dans le nom de type fourni '{1}' In queries, '{0}' must use a simple pattern Dans les requêtes, '{0}' doit utiliser un modèle simple A custom query operation for '{0}' is required but not specified Une opération de requête personnalisée pour '{0}' est requise mais non spécifiée Named static arguments must come after all unnamed static arguments Les arguments statiques nommés doivent suivre tous les arguments statiques non nommés The static parameter '{0}' of the provided type or method '{1}' requires a value. Static parameters to type providers may be optionally specified using named arguments, e.g. '{2}<{3}=...>'. Le paramètre statique '{0}' de la méthode ou du type fourni '{1}' nécessite une valeur. Les paramètres statiques envoyés aux fournisseurs de type peuvent éventuellement être spécifiés à l'aide d'arguments nommés, par ex. '{2}<{3}=...>'. No static parameter exists with name '{0}' Il n'existe aucun paramètre statique nommé '{0}' The static parameter '{0}' has already been given a value Une valeur a déjà été attribuée au paramètre statique '{0}' Multiple static parameters exist with name '{0}' Il existe plusieurs paramètres statiques nommés '{0}' A custom operation may not be used in conjunction with a non-value or recursive 'let' binding in another part of this computation expression Une opération personnalisée ne peut pas être utilisée en association avec une liaison sans valeur ou 'let' récursive dans une autre partie de cette expression de calcul A custom operation may not be used in conjunction with 'use', 'try/with', 'try/finally', 'if/then/else' or 'match' operators within this computation expression Une opération personnalisée ne peut pas être utilisée en association avec les opérateurs 'use', 'try/with', 'try/finally', 'if/then/else' ou 'match' dans cette expression de calcul The custom operation '{0}' refers to a method which is overloaded. The implementations of custom operations may not be overloaded. L'opération personnalisée '{0}' fait référence à une méthode surchargée. Les implémentations d'opérations personnalisées ne peuvent pas être surchargées. An if/then/else expression may not be used within queries. Consider using either an if/then expression, or use a sequence expression instead. Les expressions if/then/else ne peuvent pas être utilisées au sein des requêtes. Utilisez soit une expression if/then, soit une expression de séquence. Invalid argument to 'methodhandleof' during codegen Argument non valide passé à 'methodhandleof' pendant la génération du code A reference to a provided type was missing a value for the static parameter '{0}'. You may need to recompile one or more referenced assemblies. Il manque une valeur pour le paramètre statique '{0}' dans une référence à un type fourni. Vous devrez peut-être recompiler un ou plusieurs assemblys référencés. A reference to a provided type had an invalid value '{0}' for a static parameter. You may need to recompile one or more referenced assemblies. Une référence à un type fourni a une valeur non valide '{0}' pour un paramètre statique. Vous devrez peut-être recompiler un ou plusieurs assemblys référencés. '{0}' is not used correctly. This is a custom operation in this query or computation expression. '{0}' n'est pas utilisé correctement. Il s'agit d'une opération personnalisée dans cette requête ou opération de calcul. '{0}' is not used correctly. Usage: {1}. This is a custom operation in this query or computation expression. '{0}' n'est pas utilisé correctement. Utilisation : {1}. Il s'agit d'une opération personnalisée dans cette requête ou expression de calcul. {0} var in collection {1} (outerKey = innerKey). Note that parentheses are required after '{2}' var {0} dans la collection {1} (outerKey = innerKey). Notez que les parenthèses sont obligatoires après '{2}' {0} var in collection {1} (outerKey = innerKey) into group. Note that parentheses are required after '{2}' var {0} dans la collection {1} (outerKey = innerKey) au sein du groupe. Notez que les parenthèses sont obligatoires après '{2}' {0} var in collection {0} var in collection '{0}' must be followed by a variable name. Usage: {1}. '{0}' doit être suivi d'un nom de variable. Utilisation : {1}. Incorrect syntax for '{0}'. Usage: {1}. Syntaxe incorrecte pour '{0}'. Utilisation : {1}. '{0}' must come after a 'for' selection clause and be followed by the rest of the query. Syntax: ... {1} ... '{0}' doit suivre une clause de sélection 'for' et être suivi du reste de la requête. Syntaxe : ... {1} ... '{0}' is used with an incorrect number of arguments. This is a custom operation in this query or computation expression. Expected {1} argument(s), but given {2}. '{0}' est utilisé avec un nombre incorrect d'arguments. Il s'agit d'une opération personnalisée dans cette requête ou expression de calcul. {1} argument(s) attendu(s), mais {2} fourni(s). Expected an expression after this point Une expression était attendue après ce point Expected a type after this point Un type était attendu après ce point Unmatched '[<'. Expected closing '>]' '[<' sans correspondance. '>]' fermant attendu Unexpected end of input in 'match' expression. Expected 'match <expr> with | <pat> -> <expr> | <pat> -> <expr> ...'. Fin d'entrée inattendue dans l'expression 'match'. Attendu 'match <expr> with | <pat> -> <expr> | <pat> -> <expr> ...'. Unexpected end of input in 'try' expression. Expected 'try <expr> with <rules>' or 'try <expr> finally <expr>'. Fin d'entrée inattendue dans l'expression 'try'. Attendu 'try <expr> with <rules>' ou 'try <expr> finally <expr>'. Unexpected end of input in 'while' expression. Expected 'while <expr> do <expr>'. Fin d'entrée inattendue dans l'expression 'while'. Attendu 'while <expr> do <expr>'. Unexpected end of input in 'for' expression. Expected 'for <pat> in <expr> do <expr>'. Fin d'entrée inattendue dans l'expression 'for'. Attendu 'for <pat> in <expr> do <expr>'. Unexpected end of input in 'match' or 'try' expression Fin d'entrée inattendue dans l'expression 'match' ou 'try' Unexpected end of input in 'then' branch of conditional expression. Expected 'if <expr> then <expr>' or 'if <expr> then <expr> else <expr>'. Fin d'entrée inattendue dans la branche 'then' de l'expression conditionnelle. Attendu 'if <expr> then <expr>' ou 'if <expr> then <expr> else <expr>'. Unexpected end of input in 'else' branch of conditional expression. Expected 'if <expr> then <expr>' or 'if <expr> then <expr> else <expr>'. Fin d'entrée inattendue dans la branche 'else' de l'expression conditionnelle. Attendu 'if <expr> then <expr>' ou 'if <expr> then <expr> else <expr>'. Unexpected end of input in body of lambda expression. Expected 'fun <pat> ... <pat> -> <expr>'. Fin d'entrée inattendue dans le corps d'une expression lambda. Attendu 'fun <pat> ... <pat> -> <expr>'. Unexpected end of input in type arguments Fin d'entrée inattendue dans les arguments de type Unexpected end of input in type signature Fin d'entrée inattendue dans la signature de type Unexpected end of input in type definition Fin d'entrée inattendue dans la définition de type Unexpected end of input in object members Fin d'entrée inattendue dans les membres d'objet Unexpected end of input in value, function or member definition Fin d'entrée inattendue dans la définition de valeur, de fonction ou de membre Unexpected end of input in expression Fin d'entrée inattendue dans l'expression Unexpected end of type. Expected a name after this point. Fin de type inattendue. Un nom était attendu après ce point. Incomplete value or function definition. If this is in an expression, the body of the expression must be indented to the same column as the 'let' keyword. Définition de valeur ou de fonction incomplète. S'il s'agit d'une expression, le corps de l'expression doit être mis en retrait sur la même colonne que le mot-clé 'let'. Incomplete value definition. If this is in an expression, the body of the expression must be indented to the same column as the 'let!' keyword. Définition de valeur incomplète. S'il s'agit d'une expression, le corps de l'expression doit être mis en retrait sur la même colonne que le mot-clé 'let!'. Incomplete value definition. If this is in an expression, the body of the expression must be indented to the same column as the 'use!' keyword. Définition de valeur incomplète. S'il s'agit d'une expression, le corps de l'expression doit être mis en retrait sur la même colonne que le mot-clé 'use!'. Incomplete value definition. If this is in an expression, the body of the expression must be indented to the same column as the 'use' keyword. Définition de valeur incomplète. S'il s'agit d'une expression, le corps de l'expression doit être mis en retrait sur la même colonne que le mot-clé 'use'. Missing 'do' in 'while' expression. Expected 'while <expr> do <expr>'. 'do' est manquant dans l'expression 'while'. Attendu 'while <expr> do <expr>'. Missing 'do' in 'for' expression. Expected 'for <pat> in <expr> do <expr>'. 'do' manquant dans l'expression 'for'. Attendu 'for <pat> in <expr> do <expr>' Invalid join relation in '{0}'. Expected 'expr <op> expr', where <op> is =, =?, ?= or ?=?. Relation de jointure non valide dans '{0}'. Attendu 'expr <op> expr', où <op> est =, =?, ?= ou ?=?. Calls Appels Invalid number of generic arguments to type '{0}' in provided type. Expected '{1}' arguments, given '{2}'. Nombre d'arguments génériques non valide pour le type '{0}' dans le type fourni. '{1}' arguments étaient attendus, '{2}' ont été fournis. Invalid value '{0}' for unit-of-measure parameter '{1}' Valeur non valide '{0}' pour le paramètre d'unité de mesure '{1}' Invalid value unit-of-measure parameter '{0}' Valeur de paramètre d'unité de mesure non valide '{0}' Property '{0}' on provided type '{1}' is neither readable nor writable as it has CanRead=false and CanWrite=false La propriété '{0}' sur le type fourni '{1}' ne peut être ni lue ni écrite, car CanRead=false et CanWrite=false A use of 'into' must be followed by the remainder of the computation L'utilisation de 'into' doit être suivie du reste du calcul The operator '{0}' does not accept the use of 'into' L'opérateur '{0}' n'accepte pas l'utilisation de 'into' The definition of the custom operator '{0}' does not use a valid combination of attribute flags La définition de l'opérateur personnalisé '{0}' n'utilise pas de combinaison d'indicateurs d'attributs valide This type definition may not have the 'CLIMutable' attribute. Only record types may have this attribute. Cette définition de type ne peut pas avoir d'attribut 'CLIMutable'. Seuls les types d'enregistrements peuvent avoir cet attribut. 'member val' definitions are only permitted in types with a primary constructor. Consider adding arguments to your type definition, e.g. 'type X(args) = ...'. Les définitions 'member val' sont uniquement autorisées dans les types avec un constructeur principal. Ajoutez des arguments à votre définition de type, par exemple 'type X(args) =…'. Property definitions may not be declared mutable. To indicate that this property can be set, use 'member val PropertyName = expr with get,set'. Les définitions de propriété ne doivent pas être déclarées comme étant mutables. Pour indiquer que cette propriété peut être définie, utilisez 'member val PropertyName = expr with get,set'. To indicate that this property can be set, use 'member val PropertyName = expr with get,set'. Pour indiquer que cette propriété peut être définie, utilisez 'member val PropertyName = expr with get,set'. Type '{0}' is illegal because in byref<T>, T cannot contain byref types. Le type '{0}' n'est pas autorisé, car il se trouve dans byref<T>, T ne peut pas contenir de types byref. F# supports array ranks between 1 and 32. The value {0} is not allowed. F# prend en charge les rangs de tableau compris entre 1 et 32. La valeur {0} n'est pas autorisée. In queries, use the form 'for x in n .. m do ...' for ranging over integers Dans les requêtes, utilisez la forme 'for x in n .. m do …' pour couvrir les entiers 'while' expressions may not be used in queries Les expressions 'while' ne peuvent pas être utilisées dans les requêtes 'try/finally' expressions may not be used in queries Les expressions 'try/finally' ne peuvent pas être utilisées dans les requêtes 'use' expressions may not be used in queries Les expressions 'use' ne peuvent pas être utilisées dans les requêtes 'let!', 'use!' and 'do!' expressions may not be used in queries Les expressions 'let!', 'use!' et 'do!' ne sont pas utilisées dans les requêtes 'return' and 'return!' may not be used in queries 'return' et 'return!' ne peuvent pas être utilisés dans les requêtes This is not a known query operator. Query operators are identifiers such as 'select', 'where', 'sortBy', 'thenBy', 'groupBy', 'groupValBy', 'join', 'groupJoin', 'sumBy' and 'averageBy', defined using corresponding methods on the 'QueryBuilder' type. Cet opérateur de requête est inconnu. Les opérateurs de requête sont des identificateurs, tels que 'select', 'where', 'sortBy', 'thenBy', 'groupBy', 'groupValBy', 'join', 'groupJoin', 'sumBy' et 'averageBy', définis à l'aide de méthodes correspondantes sur le type 'QueryBuilder'. 'try/with' expressions may not be used in queries Les expressions 'try/with' ne peuvent pas être utilisées dans les requêtes This 'let' definition may not be used in a query. Only simple value definitions may be used in queries. Cette définition 'let' ne peut pas être utilisée dans une requête. Seules les définitions de valeur simple peuvent être utilisées dans les requêtes. Too many static parameters. Expected at most {0} parameters, but got {1} unnamed and {2} named parameters. Paramètres statiques trop nombreux. {0} paramètres au maximum étaient attendus, mais {1} paramètres non nommés et {2} paramètres nommés ont été reçus. Invalid provided literal value '{0}' Valeur littérale fournie non valide '{0}' The 'anycpu32bitpreferred' platform can only be used with EXE targets. You must use 'anycpu' instead. La plateforme 'anycpu32bitpreferred' peut uniquement être utilisée avec des cibles EXE. Vous devez utiliser 'anycpu' à la place. This member, function or value declaration may not be declared 'inline' Cette déclaration de membre, de fonction ou de valeur ne peut pas être déclarée comme étant 'inline' The provider '{0}' returned a non-generated type '{1}' in the context of a set of generated types. Consider adjusting the type provider to only return generated types. Le fournisseur '{0}' a retourné un type non généré '{1}' dans le contexte d'un ensemble de type générés. Envisagez d'ajuster le fournisseur de type de manière à retourner uniquement les types générés. Arguments to query operators may require parentheses, e.g. 'where (x > y)' or 'groupBy (x.Length / 10)' Les arguments des opérateurs de requête peuvent nécessiter des parenthèses, par ex. 'where (x > y)' ou 'groupBy (x.Length / 10)' A quotation may not involve an assignment to or taking the address of a captured local variable Une citation ne peut pas impliquer d'assignation à une variable locale capturée ou d'utilisation de l'adresse de cette dernière + 1 overload + 1 surcharge + {0} overloads + {0} surcharges Erased to Effacé de Unexpected token '{0}' or incomplete expression Jeton inattendu '{0}' ou expression incomplète Cannot find code target for this attribute, possibly because the code after the attribute is incomplete. La cible du code est introuvable pour cet attribut, peut-être parce que le code après l'attribut est incomplet. Type name cannot be empty. Le nom de type ne peut pas être vide. Problem reading assembly '{0}': {1} Problème lors de la lecture de l'assembly '{0}' : {1} Invalid provided field. Provided fields of erased provided types must be literals. Champ fourni non valide. Les champs fournis de types fournis effacés doivent être des littéraux. (loading description...) (chargement de la description...) (description unavailable...) (description non disponible...) A type variable has been constrained by multiple different class types. A type variable may only have one class constraint. Une variable de type a été contrainte par plusieurs types de classes différents. Une variable de type ne peut avoir qu'une contrainte de classe. 'match' expressions may not be used in queries Les expressions 'match' ne peuvent pas être utilisées dans les requêtes Infix operator member '{0}' has {1} initial argument(s). Expected a tuple of 3 arguments Le membre opérateur infixe '{0}' a {1} argument initiaux. Tuple de 3 arguments attendu The operator '{0}' cannot be resolved. Consider opening the module 'Microsoft.FSharp.Linq.NullableOperators'. Impossible de résoudre l'opérateur '{0}'. Essayez d'ouvrir le module 'Microsoft.FSharp.Linq.NullableOperators'. '{0}' must be followed by 'in'. Usage: {1}. '{0}' doit être suivi de 'in'. Utilisation : {1}. Neither 'member val' nor 'override val' definitions are permitted in object expressions. Les définitions 'member val' et 'override val' ne sont pas autorisées dans les expressions d'objet. Copy-and-update record expressions must include at least one field. Les expressions d'enregistrement de copie et mise à jour doivent inclure au moins un champ. '_' cannot be used as field name '_' ne peut pas être utilisé comme nom de champ The provided types generated by this use of a type provider may not be used from other F# assemblies and should be marked internal or private. Consider using 'type internal TypeName = ...' or 'type private TypeName = ...'. Les types fournis générés par cette utilisation d'un fournisseur de type ne peuvent pas être utilisés à partir d'autres assemblys F# et doivent être marqués comme internes ou privés. Envisagez d'utiliser 'type internal TypeName = ...' ou 'type private TypeName = ...'. A property's getter and setter must have the same type. Property '{0}' has getter of type '{1}' but setter of type '{2}'. Les méthodes getter et setter d'une propriété doivent avoir le même type. La propriété '{0}' a une méthode getter de type '{1}' alors que sa méthode setter est de type '{2}'. Array method '{0}' is supplied by the runtime and cannot be directly used in code. For operations with array elements consider using family of GetArray/SetArray functions from LanguagePrimitives.IntrinsicFunctions module. La méthode Array '{0}' est fournie par le runtime et ne peut pas être utilisée directement dans le code. Pour les opérations comportant des éléments Array, envisagez d'utiliser la famille de fonctions GetArray/SetArray du module LanguagePrimitives.IntrinsicFunctions. The union case '{0}' does not have a field named '{1}'. Le cas d'union '{0}' n'a pas de champ nommé '{1}'. Union case/exception field '{0}' cannot be used more than once. Le champ de cas ou d'exception d'union '{0}' ne peut pas être utilisé plusieurs fois. Named field '{0}' is used more than once. Le champ nommé '{0}' est utilisé plusieurs fois. Named field '{0}' conflicts with autogenerated name for anonymous field. Le champ nommé '{0}' est en conflit avec le nom généré automatiquement pour le champ anonyme. This literal expression or attribute argument results in an arithmetic overflow. Cette expression littérale ou cet argument d'attribut engendre un dépassement arithmétique. This is not valid literal expression. The [<Literal>] attribute will be ignored. Cette expression n'est pas une expression littérale valide. L'attribut [<Literal>] est ignoré. System.Runtime.InteropServices assembly is required to use UnknownWrapper\DispatchWrapper classes. L'assembly System.Runtime.InteropServices est requis pour l'utilisation de classes UnknownWrapper\DispatchWrapper. The mutable local '{0}' is implicitly allocated as a reference cell because it has been captured by a closure. This warning is for informational purposes only to indicate where implicit allocations are performed. Le mutable local '{0}' est implicitement alloué en tant que cellule de référence, car il a été capturé par une clôture. Cet avertissement est fourni à titre d'information uniquement pour indiquer l'emplacement où les allocations implicites sont effectuées. A type provider implemented GetStaticParametersForMethod, but ApplyStaticArgumentsForMethod was not implemented or invalid Un fournisseur de type a implémenté GetStaticParametersForMethod, mais ApplyStaticArgumentsForMethod n'a pas été implémenté ou est non valide An error occured applying the static arguments to a provided method Une erreur s'est produite durant l'application des arguments statiques à une méthode fournie Unexpected character '{0}' in preprocessor expression Caractère '{0}' inattendu dans l'expression de préprocesseur Unexpected token '{0}' in preprocessor expression Jeton '{0}' inattendu dans l'expression de préprocesseur Incomplete preprocessor expression Expression de préprocesseur incomplète Missing token '{0}' in preprocessor expression Jeton '{0}' manquant dans l'expression de préprocesseur An error occurred while reading the F# metadata node at position {0} in table '{1}' of assembly '{2}'. The node had no matching declaration. Please report this warning. You may need to recompile the F# assembly you are using. Une erreur s'est produite lors de la lecture du nœud de métadonnées F# à la position {0} dans la table '{1}' de l'assembly '{2}'. Le nœud n'avait pas de déclaration correspondante. Veuillez signaler cet avertissement. Vous devrez peut-être recompiler l'assembly F# que vous utilisez actuellement. Type inference caused the type variable {0} to escape its scope. Consider adding an explicit type parameter declaration or adjusting your code to be less generic. La variable de type {0} est sortie de sa portée à cause de l'inférence de type. Envisagez d'ajouter une déclaration de paramètre de type explicite ou d'ajuster votre code pour qu'il soit moins générique. Type inference caused an inference type variable to escape its scope. Consider adding type annotations to make your code less generic. Une variable de type d'inférence est sortie de sa portée à cause de l'inférence de type. Envisagez d'ajouter des annotations de type pour que votre code soit moins générique. Redundant arguments are being ignored in function '{0}'. Expected {1} but got {2} arguments. Les arguments redondants sont actuellement ignorés dans la fonction '{0}'. {1} attendu(s), mais {2} argument(s) obtenu(s). Lowercase literal '{0}' is being shadowed by a new pattern with the same name. Only uppercase and module-prefixed literals can be used as named patterns. Le littéral en minuscule '{0}' est actuellement caché par un nouveau modèle du même nom. Seuls les littéraux en majuscule préfixés avec un module peuvent être utilisés comme modèles nommés. This literal pattern does not take arguments Ce modèle de littéral n'accepte pas d'arguments Constructors are not permitted as extension members - they must be defined as part of the original definition of the type Les constructeurs ne sont pas autorisés en tant que membres d'extension. Ils doivent être définis dans le cadre de la définition d'origine du type Invalid response file '{0}' ( '{1}' ) Fichier réponse non valide '{0}' ('{1}') Response file '{0}' not found in '{1}' Le fichier réponse '{0}' est introuvable dans '{1}' Response file name '{0}' is empty, contains invalid characters, has a drive specification without an absolute path, or is too long Le nom du fichier réponse '{0}' est vide, contient des caractères non valides, spécifie un lecteur sans chemin absolu, ou est trop long Cannot find FSharp.Core.dll in compiler's directory FSharp.Core.dll est introuvable dans le répertoire du compilateur One tuple type is a struct tuple, the other is a reference tuple L'un des tuples est de type struct, l'autre tuple est de type référence This provided method requires static parameters La méthode fournie nécessite des paramètres statiques The conversion from {0} to {1} is a compile-time safe upcast, not a downcast. Consider using 'upcast' instead of 'downcast'. La conversion de {0} en {1} est un cast sécurisé d'un type dérivé en l'une de ses classes de base au moment de la compilation, et non un cast d'une classe de base en une classe dérivée. Utilisez 'upcast' à la place de 'downcast'. The conversion from {0} to {1} is a compile-time safe upcast, not a downcast. Consider using the :> (upcast) operator instead of the :?> (downcast) operator. La conversion de {0} en {1} est un hyperonyme sécurisé et non un hyponyme. Utilisez l'opérateur :> (hyperonyme) au lieu de l'opérateur :?> (hyponyme). The 'rec' on this module is implied by an outer 'rec' declaration and is being ignored Le mot clé 'rec' sur ce module étant impliqué par une déclaration 'rec' externe, il est ignoré In a recursive declaration group, 'open' declarations must come first in each module Dans un groupe de déclarations récursives, les déclarations 'open' doivent figurer en premier dans chaque module In a recursive declaration group, module abbreviations must come after all 'open' declarations and before other declarations Dans un groupe de déclarations récursives, les abréviations de module doivent figurer après toutes les déclarations 'open' et avant les autres déclarations This declaration is not supported in recursive declaration groups Cette déclaration n'est pas prise en charge dans les groupes de déclarations récursives Invalid use of 'rec' keyword Utilisation non valide du mot clé 'rec' If a multicase union type is a struct, then all union cases must have unique names. For example: 'type A = B of b: int | C of c: int'. Si un type d’union multi-cas est un struct, alors tous les cas d’union doivent avoir des noms uniques. Par exemple : 'type A = B de b : int | C de c : int'. The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerFilePathAttribute. CallerMemberNameAttribute, qui est appliqué au paramètre '{0}', n'aura aucun effet. Il est remplacé par CallerFilePathAttribute. Invalid use of 'fixed'. 'fixed' may only be used in a declaration of the form 'use x = fixed expr' where the expression is an array, the address of a field, the address of an array element or a string' Utilisation non valide de 'fixed'. Utilisez uniquement 'fixed' dans une déclaration de la forme 'use x = fixed expr' où l'expression est un tableau, l'adresse d'un champ, l'adresse d'un élément de tableau ou une chaîne Could not find method System.Runtime.CompilerServices.OffsetToStringData in references when building 'fixed' expression. Méthode System.Runtime.CompilerServices.OffsetToStringData introuvable dans les références durant la construction d'une expression 'fixed'. {0} is an active pattern and cannot be treated as a discriminated union case with named fields. {0} est un modèle actif. Il ne peut pas être traité comme un cas d'union discriminé avec des champs nommés. The default value does not have the same type as the argument. The DefaultParameterValue attribute and any Optional attribute will be ignored. Note: 'null' needs to be annotated with the correct type, e.g. 'DefaultParameterValue(null:obj)'. La valeur par défaut n'a pas le même type que l'argument. L'attribut DefaultParameterValue et tous les attributs facultatifs seront ignorés. Remarque : 'null' doit être annoté avec le type approprié, par ex., 'DefaultParameterValue(null:obj)'. The system type '{0}' was required but no referenced system DLL contained this type Le type système '{0}' est obligatoire, mais aucune DLL système référencée ne contient ce type The member '{0}' matches multiple overloads of the same method.\nPlease restrict it to one of the following:{1}. Le membre '{0}' correspond à plusieurs surcharges de la même méthode.\nLimitez-le à l'une des options suivantes : {1}. Method or object constructor '{0}' is not static La méthode ou le constructeur d'objet '{0}' n'est pas statique Unexpected symbol '=' in expression. Did you intend to use 'for x in y .. z do' instead? Symbole '=' inattendu dans l'expression. Souhaitiez-vous utiliser 'for x in y .. z do' à la place ? Indicates a method that either has no implementation in the type in which it is declared or that is virtual and has a default implementation. Indique une méthode qui n'a aucune implémentation dans le type dans lequel elle est déclarée, ou qui est virtuelle avec une implémentation par défaut. Used to give the current class object an object name. Also used to give a name to a whole pattern within a pattern match. Permet de donner un nom d'objet à l'objet de classe actuel. Permet également de nommer un modèle complet dans un critère spécial. Used to verify code during debugging. Permet de vérifier le code durant le débogage. Used as the name of the base class object. Utilisé comme nom de l'objet de classe de base. In verbose syntax, indicates the start of a code block. En syntaxe détaillée, indique le début d'un bloc de code. In verbose syntax, indicates the start of a class definition. En syntaxe détaillée, indique le début d'une définition de classe. Indicates an implementation of an abstract method; used together with an abstract method declaration to create a virtual method. Indique l'implémentation d'une méthode abstraite et s'utilise avec une déclaration de méthode abstraite pour créer une méthode virtuelle. Used to declare a delegate. Permet de déclarer un délégué. Used in looping constructs or to execute imperative code. Utilisé dans les constructions de boucles ou pour exécuter du code impératif. In verbose syntax, indicates the end of a block of code in a looping expression. En syntaxe détaillée, indique la fin d'un bloc de code dans une expression de boucle. Used to convert to a type that is lower in the inheritance chain. Permet de convertir en un type inférieur dans la chaîne d'héritage. In a for expression, used when counting in reverse. Dans une expression for, permet de compter en sens inverse. Used in conditional branching. A short form of else if. Utilisé dans la création de branche conditionnelle. Forme abrégée d'else if. Used in conditional branching. Utilisé dans la création de branche conditionnelle. In type definitions and type extensions, indicates the end of a section of member definitions. In verbose syntax, used to specify the end of a code block that starts with the begin keyword. Dans les définitions de type et les extensions de type, indique la fin d'une section de définitions de membre. En syntaxe détaillée, permet de spécifier la fin d'un bloc de code qui commence par le mot clé begin. Used to declare an exception type. Permet de déclarer un type d'exception. Indicates that a declared program element is defined in another binary or assembly. Indique qu'un élément de programme déclaré est défini dans une autre ressource binaire ou un autre assembly. Used as a Boolean literal. Utilisé comme littéral booléen. Used together with try to introduce a block of code that executes regardless of whether an exception occurs. Utilisé avec try pour introduire un bloc de code qui s'exécute indépendamment de toute exception. Used in looping constructs. Utilisé dans les constructions de boucle. Used in lambda expressions, also known as anonymous functions. Utilisé dans les expressions lambda, également appelées fonctions anonymes. Used as a shorter alternative to the fun keyword and a match expression in a lambda expression that has pattern matching on a single argument. Utilisé comme alternative plus courte au mot clé fun et à une expression match dans une expression lambda ayant des critères spéciaux sur un argument unique. Used to reference the top-level .NET namespace. Permet de référencer l'espace de noms .NET de niveau supérieur. Used in conditional branching constructs. Utilisé dans les constructions de création de branche conditionnelle. Used for sequence expressions and, in verbose syntax, to separate expressions from bindings. Utilisé pour les expressions de séquence et, en syntaxe détaillée, pour séparer les expressions des liaisons. Used to specify a base class or base interface. Permet de spécifier une classe de base ou une interface de base. Used to indicate a function that should be integrated directly into the caller's code. Permet d'indiquer une fonction qui doit être intégrée directement dans le code de l'appelant. Used to declare and implement interfaces. Permet de déclarer et d'implémenter des interfaces. Used to specify that a member is visible inside an assembly but not outside it. Permet de spécifier qu'un membre est visible dans un assembly mais pas à l'extérieur de celui-ci. Used to specify a computation that is to be performed only when a result is needed. Permet de spécifier un calcul à effectuer uniquement quand un résultat est nécessaire. Used to associate, or bind, a name to a value or function. Permet d'associer, ou de lier, un nom à une valeur ou une fonction. Used in computation expressions to bind a name to the result of another computation expression. Utilisé dans les expressions de calcul pour lier un nom au résultat d'une autre expression de calcul. Used to branch by comparing a value to a pattern. Permet de créer une branche en comparant une valeur à un modèle. Used to declare a property or method in an object type. Permet de déclarer une propriété ou une méthode dans un type d'objet. Used to associate a name with a group of related types, values, and functions, to logically separate it from other code. Permet d'associer un nom à un groupe de types, valeurs et fonctions connexes, pour le séparer de manière logique du reste du code. Used to declare a variable, that is, a value that can be changed. Permet de déclarer une variable, c'est-à-dire une valeur qui peut être modifiée. Used to associate a name with a group of related types and modules, to logically separate it from other code. Permet d'associer un nom à un groupe de types et de modules connexes, pour le séparer de manière logique du reste du code. Used to declare, define, or invoke a constructor that creates or that can create an object. Also used in generic parameter constraints to indicate that a type must have a certain constructor. Permet de déclarer, de définir ou d'appeler un constructeur qui crée ou 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 actually a keyword. However, not struct in combination is used as a generic parameter constraint. 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. Indicates the absence of an object. Also used in generic parameter constraints. Indique l'absence d'un objet. Utilisé également dans les contraintes de paramètre générique. Used in discriminated unions to indicate the type of categories of values, and in delegate and exception declarations. Utilisé dans les unions discriminées pour indiquer le type des catégories de valeurs, ainsi que dans les déclarations de délégué et d'exception. Used to make the contents of a namespace or module available without qualification. Permet de rendre disponible le contenu d'un espace de noms ou d'un module sans qualification. Used with Boolean conditions as a Boolean or operator. Equivalent to ||. Also used in member constraints. Utilisé avec les conditions booléennes en tant qu'opérateur or booléen. Équivaut à ||. Utilisé également dans les contraintes de membre. Used to implement a version of an abstract or virtual method that differs from the base version. Permet d'implémenter une version d'une méthode abstraite ou virtuelle qui diffère de la version de base. Restricts access to a member to code in the same type or module. Restreint l'accès à un membre au code situé dans le même type ou module. Allows access to a member from outside the type. Autorise l'accès à un membre en dehors du type. Used to indicate that a function is recursive. Permet d'indiquer qu'une fonction est récursive. Used to provide a value for the result of the containing computation expression. Utilisé pour fournir une valeur au résultat de l'expression de calcul conteneur. Used to provide a value for the result of the containing computation expression, where that value itself comes from the result another computation expression. Utilisé pour fournir une valeur au résultat de l'expression de calcul conteneur, où cette valeur provient du résultat d'une autre expression de calcul. Used in query expressions to specify what fields or columns to extract. Note that this is a contextual keyword, which means that it is not actually a reserved word and it only acts like a keyword in appropriate context. Utilisé dans les expressions de requête pour spécifier les champs ou colonnes à extraire. Notez qu'il s'agit d'un mot clé contextuel, ce qui signifie qu'il ne s'agit pas réellement d'un mot réservé et qu'il se comporte uniquement comme un mot clé dans le contexte approprié. Used to indicate a method or property that can be called without an instance of a type, or a value member that is shared among all instances of a type. Permet d'indiquer une méthode ou une propriété qui peut être appelée sans instance d'un type, ou un membre de valeur partagé entre toutes les instances d'un type. Used to declare a structure type. Also used in generic parameter constraints. Utilisé pour déclarer un type de structure. Également utilisé dans les contraintes de paramètres génériques. Used in conditional expressions. Also used to perform side effects after object construction. Utilisé dans les expressions conditionnelles. Utilisé également pour provoquer des effets secondaires après une construction d'objet. Used in for loops to indicate a range. Utilisé dans les boucles for pour indiquer une portée. Used to introduce a block of code that might generate an exception. Used together with with or finally. Permet d'introduire un bloc de code pouvant générer une exception. Utilisé avec with ou finally. Used to declare a class, record, structure, discriminated union, enumeration type, unit of measure, or type abbreviation. Permet de 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. Used to convert to a type that is higher in the inheritance chain. Permet de convertir en un type supérieur dans la chaîne d'héritage. Used instead of let for values that implement IDisposable Utilisé au lieu de let pour les valeurs qui implémentent IDisposable Used instead of let! in computation expressions for computation expression results that implement IDisposable. Utilisé au lieu de let! dans les expressions de calcul pour des résultats d'expression de calcul qui implémentent IDisposable. Used in a signature to indicate a value, or in a type to declare a member, in limited situations. Utilisé dans une signature pour indiquer une valeur, ou dans un type pour déclarer un membre, dans des situations limitées. Indicates the .NET void type. Used when interoperating with other .NET languages. Indique le type void .NET. Utilisé durant l'interaction avec d'autres langages .NET. Used for Boolean conditions (when guards) on pattern matches and to introduce a constraint clause for a generic type parameter. Utilisé pour les conditions booléennes (when guards) sur des critères spéciaux et pour introduire une clause de contrainte d'un paramètre de type générique. Introduces a looping construct. Introduit une construction de boucle. Used together with the match keyword in pattern matching expressions. Also used in object expressions, record copying expressions, and type extensions to introduce member definitions, and to introduce exception handlers. 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. Used in a sequence expression to produce a value for a sequence. Utilisé dans une expression de séquence pour produire une valeur pour une séquence. Used in a computation expression to append the result of a given computation expression to a collection of results for the containing computation expression. 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 de calcul conteneur. In function types, delimits arguments and return values. Yields an expression (in sequence expressions); equivalent to the yield keyword. Used in match expressions Dans les types de fonction, délimite les arguments et les valeurs renvoyées. Produit une expression (dans les expressions de séquence). Équivaut au mot clé yield. Utilisé dans les expressions match Assigns a value to a variable. Assigne une valeur à une variable. Converts a type to type that is higher in the hierarchy. Convertit un type en type supérieur dans la hiérarchie. Converts a type to a type that is lower in the hierarchy. Convertit un type en type inférieur dans la hiérarchie. Delimits a typed code quotation. Délimite une quotation de code typé. Delimits a untyped code quotation. Délimite une quotation de code non typé. {0} '{1}' not found in assembly '{2}'. A possible cause may be a version incompatibility. You may need to explicitly reference the correct version of this assembly to allow all referenced components to use the correct version. {0} '{1}' introuvable dans l'assembly '{2}'. Cela est peut-être dû à une incompatibilité de version. Vous devrez peut-être référencer explicitement la version appropriée de cet assembly pour permettre à tous les composants référencés d'utiliser la version nécessaire. {0} '{1}' not found in type '{2}' from assembly '{3}'. A possible cause may be a version incompatibility. You may need to explicitly reference the correct version of this assembly to allow all referenced components to use the correct version. {0} '{1}' introuvable dans le type '{2}' de l'assembly '{3}'. Cela est peut-être dû à une incompatibilité de version. Vous devrez peut-être référencer explicitement la version appropriée de cet assembly pour permettre à tous les composants référencés d'utiliser la version nécessaire. is est This value is not a function and cannot be applied. Cette valeur n'est pas une fonction et ne peut pas être appliquée. This value is not a function and cannot be applied. Did you intend to access the indexer via '{0}.[index]'? Cette valeur n'est pas une fonction et ne peut pas être appliquée. Souhaitiez-vous accéder à l'indexeur via « {0}.[index] » ? This expression is not a function and cannot be applied. Did you intend to access the indexer via 'expr.[index]'? Cette expression n'est pas une fonction et ne peut pas être appliquée. Souhaitiez-vous accéder à l'indexeur via « expr.[index] » ? This value is not a function and cannot be applied. Did you forget to terminate a declaration? Cette valeur n'est pas une fonction et ne peut pas être appliquée. Avez-vous oublié de terminer une déclaration ? The argument names in the signature '{0}' and implementation '{1}' do not match. The argument name from the signature file will be used. This may cause problems when debugging or profiling. Les noms d'arguments dans la signature '{0}' et l'implémentation '{1}' ne correspondent pas. Le nom d'argument du fichier de signature va être utilisé. Cela peut entraîner des problèmes durant le débogage ou le profilage. An error occurred while reading the F# metadata of assembly '{0}'. A reserved construct was utilized. You may need to upgrade your F# compiler or use an earlier version of the assembly that doesn't make use of a specific construct. Une erreur s'est produite durant la lecture des métadonnées F# de l'assembly '{0}'. Une construction réservée a été utilisée. Vous devrez peut-être mettre à niveau votre compilateur F# ou utiliser une version antérieure de l'assembly qui ne fait pas appel à une construction spécifique. This method or property is not normally used from F# code, use an explicit tuple pattern for deconstruction instead. Normalement, cette méthode ou propriété n'est pas utilisée dans le code F#. Utilisez plutôt un modèle de tuple explicite pour la déconstruction. This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'. Cette expression retourne une valeur de type '{0}', mais est implicitement ignorée. Utilisez 'let' pour lier le résultat à un nom, par ex. 'let result = expression'. Si vous voulez utiliser l'expression comme valeur dans la séquence, utilisez un 'yield' explicite. This expression returns a value of type '{0}' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield!'. Cette expression retourne une valeur de type '{0}', mais est implicitement ignorée. Utilisez 'let' pour lier le résultat à un nom, par ex. 'let result = expression'. Si vous voulez utiliser l'expression comme valeur dans la séquence, utilisez un 'yield!' explicite. Used in computation expressions to pattern match directly over the result of another computation expression. Permet dans les expressions de calcul d'appliquer directement des critères spéciaux au résultat d'une autre expression de calcul. The file '{0}' changed on disk unexpectedly, please reload. Changement inattendu du fichier '{0}' sur le disque. Rechargez le fichier. The byref pointer is readonly, so this write is not permitted. Le pointeur byref étant en lecture seule, cette écriture n'est pas autorisée. A value must be mutable in order to mutate the contents or take the address of a value type, e.g. 'let mutable x = ...' Une valeur doit être mutable pour pouvoir muter le contenu ou accepter l'adresse d'un type valeur, par exemple 'let mutable x = ...' A ReadOnly attribute has been applied to a struct type with a mutable field. Un attribut ReadOnly a été appliqué à un type struct avec un champ mutable. A byref pointer returned by a function or method is implicitly dereferenced as of F# 4.5. To acquire the return value as a pointer, use the address-of operator, e.g. '&f(x)' or '&obj.Method(arg1, arg2)'. Un pointeur byref retourné par une fonction ou une méthode est implicitement déréférencé à partir de F# 4.5. Pour acquérir la valeur de retour sous forme de pointeur, utilisez l'opérateur d'adresse, par ex. '&f(x)' ou '&obj.Method(arg1, arg2)'. A type annotated with IsByRefLike must also be a struct. Consider adding the [<Struct>] attribute to the type. Un type annoté avec IsByRefLike doit aussi être un struct. Ajoutez l'attribut [<Struct>] au type. The address of the variable '{0}' or a related expression cannot be used at this point. This is to ensure the address of the local value does not escape its scope. L'adresse de la variable '{0}' ou une expression associée ne peut pas être utilisée à ce stade. Cela permet de s'assurer que l'adresse de la valeur locale ne sort pas de sa portée. This value can't be assigned because the target '{0}' may refer to non-stack-local memory, while the expression being assigned is assessed to potentially refer to stack-local memory. This is to help prevent pointers to stack-bound memory escaping their scope. Impossible d’affecter cette valeur car la cible '{0}' peut faire référence à une mémoire non locale (hors de la pile), tandis que l'expression en cours d’affectation est évaluée comme faisant potentiellement référence à une mémoire locale (dans la pile). Cela permet d'éviter que les pointeurs vers la mémoire liée à la pile ne sortent de leur portée. A value defined in a module must be mutable in order to take its address, e.g. 'let mutable x = ...' Une valeur définie dans un module doit être mutable pour prendre son adresse. Par exemple : 'let mutable x = ...'. A type annotated with IsReadOnly must also be a struct. Consider adding the [<Struct>] attribute to the type. Un type annoté avec IsReadOnly doit aussi être un struct. Ajoutez l'attribut [<Struct>] au type. Struct members cannot return the address of fields of the struct by reference Les membres du struct ne peuvent pas retourner l'adresse des champs du struct par référence The function or method call cannot be used at this point, because one argument that is a byref of a non-stack-local Span or IsByRefLike type is used with another argument that is a stack-local Span or IsByRefLike type. This is to ensure the address of the local value does not escape its scope. Impossible d’utiliser l'appel de fonction ou de méthode à ce stade, car un argument qui est un byref d'un type Span ou IsByRefLike non local (hors de la pile) est utilisé avec un autre argument de type Span ou IsByRefLike local (dans la pile). Cela permet d'éviter que l'adresse de la valeur locale ne sorte de sa portée. The address of a value returned from the expression cannot be used at this point. This is to ensure the address of the local value does not escape its scope. L'adresse d'une valeur retournée par l'expression ne peut pas être utilisée à ce stade. Cela permet d'éviter que l'adresse de la valeur locale ne sorte de sa portée. The Span or IsByRefLike variable '{0}' cannot be used at this point. This is to ensure the address of the local value does not escape its scope. Impossible d’utiliser la variable Span ou IsByRefLike '{0}' à ce stade. Cela permet d'éviter que l'adresse de la valeur locale ne sorte de sa portée. A Span or IsByRefLike value returned from the expression cannot be used at ths point. This is to ensure the address of the local value does not escape its scope. Impossible d’utiliser une valeur Span ou IsByRefLike retournée par l'expression à ce stade. Cela permet d'éviter que l'adresse de la valeur locale ne sorte de sa portée. Cannot take the address of the value returned from the expression. Assign the returned value to a let-bound value before taking the address. Impossible de prendre l'adresse de la valeur retournée par l'expression. Assignez la valeur retournée à une valeur liée à let avant de prendre l'adresse. Unmatched '{{|' '{{|' incompatible anonymous record field champ d'enregistrement anonyme The exception '{0}' does not have a field named '{1}'. L'exception '{0}' n'a pas de champ nommé '{1}'. Active patterns do not have fields. This syntax is invalid. Les modèles actifs n'ont pas de champ. Cette syntaxe n'est pas valide. The constructor does not have a field named '{0}'. Le constructeur n'a pas de champ nommé '{0}'. Two anonymous record types are from different assemblies '{0}' and '{1}' Deux types d'enregistrement anonyme proviennent d'assemblys différents '{0}' et '{1}' This anonymous record does not exactly match the expected shape. Add the missing fields {0} and remove the extra fields {1}. Cet enregistrement anonyme ne correspond pas exactement à la forme attendue. Ajoutez les champs manquants {0} et supprimez les champs supplémentaires {1}. Cannot call the byref extension method '{0}. The first parameter requires the value to be mutable or a non-readonly byref type. Impossible d’appeler la méthode d’extension byref « {0} ». Le premier paramètre nécessite que la valeur soit mutable ou un type byref autre qu'en lecture seule. Byref types are not allowed to have optional type extensions. Les types ByRef ne sont pas autorisés à avoir des extensions de type en option. Cannot partially apply the extension method '{0}' because the first parameter is a byref type. Impossible d'appliquer partiellement la méthode d’extension « {0} » car le premier paramètre est un type byref. This type does not inherit Attribute, it will not work correctly with other .NET languages. Ce type n'hérite pas d'attribut, il ne fonctionne pas correctement avec d'autres langages .NET. Invalid anonymous record expression Expression d'enregistrement anonyme non valide Invalid anonymous record type Type d'enregistrement anonyme non valide The input to a copy-and-update expression that creates an anonymous record must be either an anonymous record or a record L'entrée d'une expression de copie et mise à jour qui crée un enregistrement anonyme doit être un enregistrement anonyme ou un enregistrement The parameter '{0}' has an invalid type '{1}'. This is not permitted by the rules of Common IL. Le paramètre « {0} » a un type non valide (« {1} »), ce qui n'est pas autorisé par les règles de Common IL. The function or method has an invalid return type '{0}'. This is not permitted by the rules of Common IL. La méthode ou la fonction a un type de retour non valide (« {0} »), ce qui n’est pas autorisé par les règles de Common IL. No implementation was given for those members: {0} Aucune implémentation pour ces membres : {0} No implementation was given for those members: {0}Note that all interface members must be implemented and listed under an appropriate 'interface' declaration, e.g. 'interface ... with member ...'. Aucune implémentation pour ces membres : {0} Notez que tous les membres d'interface doivent être implémentés et listés sous une déclaration 'interface' appropriée, par ex., 'interface ... with member ...'. No implementation was given for those members (some results omitted): {0} Aucune implémentation pour ces membres (certains résultats sont omis) : {0} No implementation was given for those members (some results omitted): {0}Note that all interface members must be implemented and listed under an appropriate 'interface' declaration, e.g. 'interface ... with member ...'. Aucune implémentation pour ces membres (certains résultats sont omis) : {0} Notez que tous les membres d'interface doivent être implémentés et listés sous une déclaration 'interface' appropriée, par ex., 'interface ... with member ... '. Expression does not have a name. L'expression n'a pas de nom. Using the 'nameof' operator as a first-class function value is not permitted. L'utilisation de l'opérateur 'nameof' comme valeur de fonction de première classe n'est pas autorisée. Maps physical paths to source path names output by the compiler Mappe les chemins physiques aux noms de chemin source générés par le compilateur Invalid path map. Mappings must be comma separated and of the format 'path=sourcePath' Mappage de chemin non valide. Les mappages doivent être séparés par des virgules et au format 'path=sourcePath' Reference an assembly or directory containing a design time tool (Short form: -t) Référence un assembly ou un répertoire contenant un outil design-time (forme courte : -t) Package manager key '{0}' was not registered in {1}. Currently registered: {2} La clé '{0}' du gestionnaire de packages n'était pas inscrite dans {1}. L'inscription a été effectuée : {2} {0} {0} The dependency manager extension {0} could not be loaded. Message: {1} Impossible de charger l'extension du gestionnaire de dépendances {0}. Message : {1}