Nouveautés de F# 11

Bienvenue dans F# 11 ! Cette version vous permet de mieux distinguer les modèles de domaine, de réutiliser des algorithmes génériques, de coordonner les opérations asynchrones et de réduire la consommation mémoire du compilateur.

Merci à la communauté F# pour les propositions, les implémentations, les révisions et les tests derrière ces changements. Des liens vers les contributeurs accompagnent les fonctionnalités présentées ci-dessous.

Note

Les exemples nécessitent un compilateur F# 11 et FSharp.Core 11 prenant en charge les fonctionnalités présentées. Dans le SDK .NET 11.0.100, les fonctionnalités de F# 11.2 nécessitent <LangVersion>preview</LangVersion> ; consultez Paramètres du langage et prise en charge prévue dans les SDK. L’exemple d’exécution asynchrone nécessite des conditions d’exécution supplémentaires ; un SDK .NET 11 antérieur ne contient pas nécessairement toutes les modifications requises.

Opérateurs de propagation des enregistrements : distinguer les modèles sans multiplier les conversions

Pour conserver des modèles de stockage et des modèles applicatifs distincts, les opérateurs de propagation des enregistrements permettent de réutiliser leurs champs communs sans avoir à les redéclarer. Dans cet exemple, les modèles partagent les informations relatives au client, mais utilisent des types différents pour leurs identificateurs :

open System

type CustomerId = CustomerId of Guid

type CustomerDetails = { Name: string; PreferredLanguage: string }

type CustomerRow =
    { ...CustomerDetails
      Id: string
      InternalNote: string }

type Customer =
    { ...CustomerDetails
      Id: CustomerId }

...CustomerDetails contribue à la déclaration des champs. À la frontière entre les deux modèles, ...row copie les valeurs, tandis que la conversion analyse l’identificateur :

let toCustomer (row: CustomerRow) =
    match Guid.TryParse row.Id with
    | true, id -> Ok ({ ...row; Id = CustomerId id }: Customer)
    | false, _ -> Error "Invalid customer identifier."

La destination conserve les détails partagés, remplace Id et exclut InternalNote. Guid.TryParse, et non le spread, valide l’identificateur ; une entrée mal formée produit Error.

Cette fonctionnalité répond au problème de conversion entre les modèles de la couche applicative. Les opérateurs de propagation de valeurs permettent également de combiner des enregistrements nommés et anonymes ; les opérateurs de propagation de types créent uniquement des enregistrements nommés. En cas de conflit, les champs déclarés ultérieurement sont prioritaires et les sources sont évaluées une seule fois, dans l’ordre. Consultez Opérateurs de propagation d’enregistrements pour découvrir des exemples de composition et les risques liés à l’évolution partagée des modèles.

Merci à @brianrourkeboll pour les propagations d’enregistrements.

Membres d’extension pour les algorithmes génériques, les opérateurs et les tuples

Pour partager un algorithme entre des types existants, F# 11.2 permet aux membres d’extension de satisfaire les contraintes des paramètres de type résolus statiquement (SRTP). Par exemple, une transformation peut gérer des listes et des options sans types wrapper.

Note

Dans le SDK .NET 11.0.100, activez <LangVersion>preview</LangVersion> à l’emplacement où les extensions sont résolues et ouvrez leur module. Consultez Exigences relatives aux bibliothèques.

Partager une transformation entre les listes et les options

Une fois le map de la bibliothèque accessible dans le contexte, l’application peut nettoyer chacune des deux représentations, modifier les types des éléments et composer des transformations :

let inline cleanNames values =
    map (fun (name: string) -> name.Trim().ToUpperInvariant()) values

let batch: string list = cleanNames [ " Ada "; " grace " ]
let optional: string option = cleanNames (Some " linus ")
let missing: string option = cleanNames (None: string option)
let lengths: int list = map String.length batch
let nested: int option list = map (map String.length) [ Some "abc"; None ]

printfn "%A; %A; %A" batch optional missing
printfn "%A; %A" lengths nested
// ["ADA"; "GRACE"]; Some "LINUS"; None
// [3; 5]; [Some 3; None]

Les adaptateurs dans Structural.Adapters utilisent des opérations familières, sans imposer de nouveaux conteneurs :

type List<'T> with
    static member Map(source: 'T list, mapping: 'T -> 'U) : 'U list =
        List.map mapping source

type Option<'T> with
    static member Map(source: 'T option, mapping: 'T -> 'U) : 'U option =
        Option.map mapping source

La fonction partagée dans Structural.Algorithms demande au type d’entrée de fournir un membre statique Map :

let inline map (mapping: 'T -> 'U) (source: ^Input) : ^Output =
    (^Input :
        (static member Map: ^Input * ('T -> 'U) -> ^Output)
        (source, mapping))

^Input et ^Output sont des types résolus statiquement. À chaque appel concret, le compilateur sélectionne le membre avec la signature requise. Les extensions n’ajoutent pas d’implémentation d’interface. L’application complète ouvre les deux modules.

Opérateurs, contexte et types de sortie

Le même mécanisme prend en charge les opérateurs de tuple et la propagation du contexte et la construction dirigée par la sortie. Pour les en-têtes de tuples natifs, la fonctionnalité F# 11.2 doit être activée à la fois lors de leur déclaration et aux points d’appel où les extensions sont résolues.

Un ajout distinct , AllowOverloadOnReturnTypepermet à une fabrique de déclarer des surcharges distinguées par leurs retours :

type Inject =
    [<AllowOverloadOnReturnType>]
    static member Pure(value: 'T) : 'T list = [value]

    [<AllowOverloadOnReturnType>]
    static member Pure(value: 'T) : 'T option = Some value

let batch: string list = Inject.Pure "ready"
let optional: string option = Inject.Pure "ready"
// ["ready"] and Some "ready"

Cet attribut Core 11 ne nécessite pas d’aperçu. L’annotation de résultat sélectionne une surcharge ; sans elle l’appel reste ambigu. Consultez Sélection selon le type de retour.

Merci à @gusty pour avoir étendu la prise en charge de la programmation générique.

intégration .NET et l’expérience de développement

Les délégués directs préservent le véritable contrat du gestionnaire

Pour exposer aux infrastructures les noms des gestionnaires et les attributs de liaison, F# 11 peut cibler directement une fonction nommée compatible au lieu d’une fonction wrapper. Les API minimales d’ASP.NET Core peuvent ensuite lire le contrat de route, de service et d’en-tête HTTP :

open System
open Microsoft.AspNetCore.Builder
open Microsoft.AspNetCore.Mvc
open Microsoft.Extensions.DependencyInjection

type ShipmentStore() =
    member _.Status trackingId =
        if trackingId = "SHP-1042" then "Dispatched" else "Unknown"

let status
    (trackingId: string)
    ([<FromServices>] store: ShipmentStore)
    ([<FromHeader(Name = "X-Customer")>] customer: string) =
    $"{customer}: {trackingId} is {store.Status trackingId}"

let handler = Func<string, ShipmentStore, string, string>(status)

Consultez le projet exécutable ainsi que les règles de construction et de compatibilité. La capture de variables et l’adaptation des arguments peuvent toujours nécessiter des wrappers.

Merci à @kerams pour les délégués directs.

Réutiliser la documentation XML

Pour centraliser les remarques sur les API, placez-les dans shared.xml :

<docs>
  <tracking>
    <remarks>An unrecognized tracking identifier has status Unknown.</remarks>
  </tracking>
</docs>

Lorsque GenerateDocumentationFile est activé, F# 11 développe <include> dans les entrées des membres générées :

/// <summary>Find the latest status of a shipment.</summary>
/// <include file="shared.xml" path="/docs/tracking/*"/>
let status trackingId =
    if trackingId = "SHP-1042" then "Dispatched" else "Unknown"

/// <summary>Find the latest statuses of several shipments.</summary>
/// <include file="shared.xml" path="/docs/tracking/*"/>
let statuses trackingIds =
    trackingIds |> List.map (fun id -> id, status id)

L’implémentation include permet de mettre à jour les deux descriptions à partir d’un seul fragment. Séparément, le résolveur d’outillage expose les descriptions de base pour <inheritdoc/>; le compilateur laisse cette balise pour les consommateurs de documentation. Consultez la documentation XML pour des exemples et les règles de résolution.

Merci à @T-Gro pour la documentation XML partagée dans FSharp.Core.

Déboguer les fonctions inline dans les builds sans optimisation

Pour examiner les arguments des fonctions d’assistance inline, définissez un point d’arrêt sur let total dans une build sans optimisation, puis effectuez un pas à pas détaillé dans addFee. Dans ces builds, F# 11 privilégie désormais les méthodes appelables :

let inline addFee (fee: decimal) (amount: decimal) =
    let total = amount + fee
    total

let invoiceTotal = addFee 2m 40m
printfn "%M" invoiceTotal
// 42

Les builds optimisées conservent l’inlining. Certaines constructions doivent toujours être développées. Consultez Déboguer les fonctions inline pour connaître ces limites et le paramètre --always-inline.

Coordination des opérations Async et Task

Pour connecter les workflows F# aux API basées sur les tâches, FSharp.Core 11 ajoute des passerelles sensibles à l’annulation, des lots de taille limitée et des transformations de résultats.

Limiter le nombre d’opérations d’E/S simultanées, pas seulement le nombre de résultats

Un grand lot de lectures peut lancer plus d’opérations que ce qu’une application devrait avoir en cours d’exécution. Pour déterminer quand les tâches doivent démarrer, un coordinateur a besoin de fabriques, et non de tâches déjà démarrées :

open System.IO
open System.Threading

let readFiles (paths: seq<string>) (ct: CancellationToken) =
    paths
    |> Seq.map (fun path ->
        fun token -> File.ReadAllTextAsync(path, token))
    |> Task.parallelLimit 4 ct

Quatre lectures au maximum s’exécutent simultanément ; les résultats conservent l’ordre des entrées. En cas d’échec, les jetons fournis permettent de demander l’annulation des tâches associées. Cela limite la simultanéité, et non le nombre de requêtes par seconde. Consultez Fonctions Async et Task pour les variantes séquentielles et celles qui renvoient une valeur unit.

Préserver l’annulation et l’exception sous-jacente lors du passage d’une API à l’autre

Lorsqu’un flux de travail lance un traitement externe, son jeton doit être transmis avec celui-ci. Async.StartTaskImmediate transmet le jeton du workflow en cours d’exécution à la fabrique de tâches et attend la fin :

open System.IO

let tryReadFile path =
    async {
        try
            let! contents =
                Async.StartTaskImmediate(fun ct -> File.ReadAllTextAsync(path, ct))
            return Some contents
        with :? FileNotFoundException ->
            return None
    }

L’échec d’une seule tâche transmet au gestionnaire l’exception sous-jacente FileNotFoundException. Pour une Task ou une ValueTask déjà créée, utilisez Async.Await ; l’ancienne Async.AwaitTask conserve son comportement d’encapsulation des exceptions.

Pour les appelants utilisant des tâches, Task.startAsyncImmediate token workflow fournit la conversion inverse. Il démarre sur le thread appelant jusqu’à la première suspension asynchrone.

Utiliser les fonctions d’assistance adaptées aux transformations simples

Pour transformer un résultat sans expression de calcul complète, utilisez les helpers correspondants dans Microsoft.FSharp.Control. Par exemple, lisez un fichier, obtenez sa longueur et retournez un échec ordinaire sous la forme de Error :

open System.IO
open System.Threading

let fileLength (path: string) (ct: CancellationToken) =
    File.ReadAllTextAsync(path, ct)
    |> Task.map String.length
    |> Task.catch

Un fichier contenant Report 1 renvoie Ok 8 ; un fichier introuvable renvoie un Error contenant FileNotFoundException. L’annulation continue d’être propagée. Async et ValueTask offrent des équivalents correspondants map, bind et des helpers d’erreur ; consultez les fonctions asynchrones et de tâches. Utilisez une expression de calcul pour les branches ou plusieurs valeurs dépendantes.

Les fonctions d’assistance ValueTask nécessitent la version Core avec netstandard2.1 ou net10.0, ainsi qu’une consommation unique.

Merci à @bartelink pour ses contributions à l’API async/task.

Relancer une exception après le signalement asynchrone d’un échec

La journalisation opérationnelle doit ajouter des informations sans modifier ce que l’appelant intercepte ou masquer où l’échec a commencé. Les gestionnaires d’expressions de calcul peuvent désormais utiliser reraise () même après avoir attendu le logger :

Note

La relance d’exception dans une expression de calcul est une fonctionnalité de F# 11.2. Dans le sdk .NET 11.0.100, activez <LangVersion>preview</LangVersion>.

open System
open System.IO
open System.Threading.Tasks

let readReport (logFailure: exn -> Task) path =
    task {
        try
            return! File.ReadAllTextAsync(path)
        with :? IOException as error ->
            do! logFailure error
            return reraise ()
    }

Une fois la journalisation effectuée, la même exception est propagée avec les informations du point de déclenchement d’origine. Un échec du journaliseur peut remplacer l’exception d’origine. Cela répond à la demande d’observabilité asynchrone sans asynchronisme à l’exécution. Consultez Relancer une exception à partir d’une expression de calcul.

Merci à @xperiandri pour ce support.

FSharp.Core peut être compilé sur les versions récentes de .NET

Pour utiliser des API modernes sans abandonner la prise en charge des anciennes cibles, FSharp.Core ajoute net10.0 aux côtés de netstandard2.0 et de netstandard2.1. NuGet sélectionne la build compatible. La mise à jour des outils permet également la libération asynchrone des ressources basée sur Task dans F# Interactive, comme dans les projets compilés. Consultez les frameworks cibles FSharp.Core.

Merci à pour le @T-Gro et le packaging des outils SDK.

Async à l’exécution pour les auteurs de générateurs

Les auteurs du générateur peuvent laisser le runtime suspendre et reprendre les méthodes marquées au lieu d’utiliser des machines d’état générées par le compilateur. Un builder expérimental défini par la bibliothèque expose le mécanisme en tant qu’expression de calcul :

let readManifest (path: string) =
    runtimeTask {
        let! text = System.IO.File.ReadAllTextAsync path
        return text.Length
    }

Note

Ce générateur expérimental utilise une fonctionnalité de F# 11.2 à l’endroit où son implémentation inline est définie ou développée ; dans le SDK .NET 11.0.100, activez le mode préversion. Elle nécessite également la build et les références de Core 11 net10.0, ainsi qu’un environnement d’exécution prenant en charge runtime-async. La combinaison runtime/référence vérifiée ici est .NET 11 RC1. Le ciblage de .NET 10 à lui seul n'est pas suffisant. Consultez les expériences Runtime async.

FSharp.Core n’inclut pas cet exemple en tant que builder à usage général. Le code task et async ordinaire ne bascule pas automatiquement vers cette fonctionnalité. Les appelants d’une API Task ordinaire déjà compilée n’ont pas besoin d’activer le mode préversion.

Merci à @majocha pour l’async runtime.

Texte natif compatible avec l’AOT et tableaux à deux dimensions

Pour prendre en charge AOT natif, F# 11 supprime, pour les opérations de texte et de tableau les plus courantes, les exigences de mise en forme basées sur la réflexion et d’allocation dynamique.

Lorsque vous avez déjà une chaîne, vous n’avez pas besoin d’un format "%s" pour l’écrire. Les nouvelles fonctions Core print et printn acceptent des valeurs via la conversion string de F# ; printn ajoute un retour à la ligne :

let report (processed: int) (total: decimal) (elapsed: TimeSpan) : string =
    $"{processed} items, total {total:F2}, elapsed {elapsed.TotalMilliseconds:F0} ms"

printn (report 12 145.50m (TimeSpan.FromMilliseconds 250.0))
// 12 items, total 145.50, elapsed 250 ms

L’interpolation de chaîne utilise la conversion directe et String.Concat dans davantage de cas. Les champs de format .NET tels que {total:F2} utilisent un formatage invariant et encadrent la valeur dans un objet ; %A et les formats printf avec précision peuvent toujours nécessiter le formatage printf. Sélectionnez une culture explicite pour la sortie localisée.

Avec --reflectionfree, les records et les unions obtiennent également une sortie générée ToString. Consultez Interpolation et AOT natif pour obtenir des exemples de culture et des chemins pris en charge.

Merci à @bbatsov pour les fonctions d’impression et @charlesroddie pour l’implémentation d’interpolation.

Conserver les opérations ordinaires de grille basée sur zéro

Une grille de base zéro ne doit pas nécessiter de module Array2D de remplacement simplement pour éviter un chemin d’allocation de code dynamique. Les implémentations principales mises à jour prennent en charge l’initialisation et la transformation familières :

let grid = Array2D.init 3 4 (fun row column -> row * 4 + column)
let doubled = grid |> Array2D.map (fun value -> value * 2)
let snapshot = Array2D.copy doubled

printn $"{snapshot.GetLength(0)} x {snapshot.GetLength(1)}; last = {snapshot[2, 3]}"
// 3 x 4; last = 22

Array2D.create, init et rebase utilisent le chemin d’allocation à partir de zéro dans toutes les versions de Core. Les fonctions map, mapi et copy, qui préservent les limites, peuvent utiliser une nouvelle API d’allocation .NET dans la build net10.0 ; les builds .NET Standard conservent leur solution de remplacement. Les tableaux non basés sur zéro ne sont pas dépréciés, mais leurs restrictions d’allocation natives restent.

Consultez Tableaux à deux dimensions et Native AOT pour connaître les chemins d’allocation et les restrictions restantes. Vérifiez les diagnostics de publication de l’application complète.

Merci à @T-Gro pour les améliorations array2D.

Moins de mémoire conservée et moins de travail répété

F# 11 réduit l’analyse répétée du compilateur et certaines allocations d’application. Celles-ci affectent différents workloads.

Partager des bibliothèques référencées entre des projets

Pour éviter de recopier les dépendances binaires partagées, le service de langage peut partager entre les projets les graphes de bibliothèques importées compatibles.

Dans l’expérience de mesure de la mémoire conservée de la PR d’implémentation, la solution ReSharper.FSharp, composée de dix projets, est passée de 1 547,2 Mo à 1 002,2 Mo avec le partage activé. Il s’agit d’une mesure avec et sans partage pour cette charge de travail, et non d’une réduction générale entre F# 10 et F# 11. Les solutions dominées par les références de projet plutôt que les références binaires partagées peuvent voir des gains beaucoup plus petits.

La lecture des métadonnées et la spécialisation inline réduisent également les allocations temporaires. Il s’agit d’une mesure distincte. Consultez Performances des outils pour connaître le périmètre et les paramètres de contrôle.

Merci à @auduchinok pour les importations de bibliothèques partagées.

Compiler par défaut les opérations indépendantes en parallèle

La compilation parallèle est désormais activée par défaut, tout en préservant la détermination des résultats et les règles d’ordre du code source. La mise en cache des surcharges et les améliorations des motifs avec garde évitent également les traitements répétitifs. Visual Studio/FCS réduisent également les analyses des documents inchangés et limitent le nombre de vérifications simultanées ; consultez Performances des outils.

Réduire les allocations liées aux rappels et aux résultats vides

Certaines fonctions List et Array intègrent désormais les rappels. Pour vos propres fonctions d’assistance inline, OptimizeClosureIfNotInlined adapte une seule fois un rappel curryfié opaque :

let inline foldItems
    ([<InlineIfLambda; OptimizeClosureIfNotInlined>] folder)
    state
    (items: 'T[]) =
    let mutable total = state
    for item in items do
        total <- folder total item
    total

D’autres allocations peuvent subsister. Consultez Optimiser les rappels curryfiés pour connaître les exigences.

Les résultats vides constituent un autre cas fréquent d’opération réussie. Le scénario à l’origine de cette amélioration dans FSharpLint combinait régulièrement des règles qui ne détectaient aucun avertissement. Core réutilise désormais des tableaux vides partagés dans davantage d’opérations :

let checkTitle (title: string) =
    if String.IsNullOrWhiteSpace title then [|"A title is required."|]
    else Array.empty

let warnings = ["Introduction"; "Installation"] |> List.toArray |> Array.collect checkTitle
let sharedEmpty = obj.ReferenceEquals(warnings, Array.empty<string>)
// true: no new empty result array

La modification supprime les objets tableau vide redondants, pas toutes les allocations dans le pipeline. Ne supposez pas que des résultats vides distincts ont des références d’objet différentes.

Merci à @T-Gro pour les rappels inline dans les collections et les tableaux vides partagés.

Appels d’API plus précis et améliorations pratiques

Exiger des noms lorsque l’ordre de paramètre généré peut changer

Pour protéger les API générées contre les modifications silencieuses de l’ordre des paramètres, un auteur peut exiger des arguments nommés :

Note

L’application des contraintes est une fonctionnalité de F# 11.2 ; dans le SDK .NET 11.0.100, activez le mode préversion. Une définition disponible System.Diagnostics.CodeAnalysis.RequireNamedArgumentsAttribute est également requise. L’exemple complet fournit une définition de compatibilité pour les références qui ne l’ont pas.

open System.Diagnostics.CodeAnalysis

type Query =
    [<RequireNamedArguments>]
    static member Execute(numerator: decimal, denominator: decimal) =
        numerator / denominator

let ratio = Query.Execute(numerator = 3m, denominator = 4m)
// 0.75M; Query.Execute(3m, 4m) is rejected.

La réorganisation de la déclaration conserve le résultat de l’appel nommé ; 0.75Mun appel positionnel est rejeté. Pour le cas d’utilisation des API générées, le fournisseur doit émettre l’annotation.

Reconnaître un argument générique déjà encapsulé

Pour éviter de traiter une tâche existante comme une simple valeur de résultat, une nouvelle règle de résolution des surcharges, utilisée en dernier recours, privilégie Task<'T> plutôt que 'T seul :

Note

Le critère de départage fondé sur le type le plus concret et le comportement de priorité des surcharges sont des fonctionnalités de F# 11.2 ; dans le SDK .NET 11.0.100, activez le mode préversion.

open System.Threading.Tasks

let pending = Task.FromResult 42
let wrapped = ValueTask<_>(pending)
let answer: int = wrapped.Result
// ValueTask<int>, not ValueTask<Task<int>>

Le résultat est ValueTask<int>, pas ValueTask<Task<int>>. Consultez Overload selection pour connaître les limites de la règle.

Préférer une nouvelle surcharge sans supprimer l’ancien point d’entrée

Une bibliothèque peut conserver une ancienne méthode de diagnostic pour les fichiers binaires existants tout en ajoutant une surcharge de fonction qui inclut l’emplacement source de l’appelant. OverloadResolutionPriorityAttribute rend cette préférence explicite pour les appelants nouvellement compilés :

open System.Runtime.CompilerServices

type Check =
    static member That(condition: bool) =
        if condition then "OK" else "Check failed."

    [<OverloadResolutionPriority(1)>]
    static member That(condition: bool, [<CallerLineNumber>] ?line: int) =
        if condition then "OK" else $"Check failed at line {defaultArg line 0}."

let stock = 0
let diagnostic = Check.That(stock > 0)
// The diagnostic includes the caller's source line.

Sans modification de l’appel, la surcharge qui tient compte du numéro de ligne est sélectionnée. Consultez Sélection des surcharges pour connaître l’étendue et les règles de compatibilité.

Utiliser les promesses de nullabilité conditionnelle de .NET

Si votre chemin d'accès de fichier n'est pas null, le résultat nullable d'une API Path ne doit pas forcer une vérification que son propre contrat exclut. F# 11 s’appuie sur la garantie .NET existante : une entrée nommée non null implique un résultat non null.

open System.IO

let fileName: string = Path.GetFileName("reports/annual.csv")
let extension: string = Path.GetExtension(fileName)
printn (extension.ToUpperInvariant())
// .CSV

let fileNameOf (path: string | null) : string | null =
    Path.GetFileName path

Activez <Nullable>enable</Nullable>. Les paramètres acceptant la valeur null ont toujours besoin d’une gestion des valeurs nulles ; consultez les contrats de retour conditionnels. Pour les API C# T? sans contraintes, utilisez la fonction d’assistance distincte Unchecked.withNull.

Merci à @kerams pour la prise en charge conditionnelle de la nullabilité.

Autres améliorations du langage

Pour appeler un type d’enregistrement avec la syntaxe de constructeur .NET, utilisez les constructeurs d’enregistrements F# 11.2 :

type Person = { Name: string; Age: int }
let person = Person(Name = "Ada", Age = 36)

Les arguments nommés évitent la dépendance à l’ordre des champs. Merci à @charlesroddie pour cette fonctionnalité.

Pour la source conditionnelle, #elif évite les groupes #if imbriqués :

#if EU_WAREHOUSE
let dispatchTimeZone = "Europe/Paris"
#elif US_WAREHOUSE
let dispatchTimeZone = "America/New_York"
#else
let dispatchTimeZone = "UTC"
#endif

System.Console.WriteLine(dispatchTimeZone)

La première branche correspondante gagne. L’exemple de projet définit EU_WAREHOUSE et imprime Europe/Paris; avec aucun symbole défini, la sortie est UTC.

Pour les outils associés et les cas d’interopérabilité :

Avant la mise à niveau

Lors de la mise à niveau, tenez compte des modifications importantes suivantes :

Code affecté Action
Bibliothèques contenant des fichiers .fsi Copiez les attributs de contrat appliqués dans les signatures ; leur absence génère désormais des erreurs FS3888.
Bibliothèques inline utilisant des extensions Passez en revue les signatures déduites et les exigences de producteur/consommateur. L’inférence F# 11.2 peut conserver des contraintes plus générales.
Délégués de méthodes d’instance Validez les récepteurs avant la construction directe, car les erreurs liées aux récepteurs null se produisent désormais à ce stade.
Sortie interpolée localisée Les champs de format .NET utilisent la culture invariante. Choisissez une culture explicite si une sortie localisée est attendue.
Générateurs personnalisés avec do! Fournissez la liaison et la finalisation de type unit ; le do! final ne sélectionne plus les membres de transfert final.
Non terminé let! Ajoutez le corps de calcul suivant ; une liaison incomplète a désormais un diagnostic plus direct.
Paramètres de langage antérieurs Les modes numérotés pris en charge commencent à F# 8 ; Le mode de retrait non strict est supprimé. Consultez la version linguistique et l’indentation.
Opérations bit à bit sur les énumérations Utilisez des énumérations basées sur des types entiers ; les types sous-jacents non valides sont rejetés.