Voici la présentation des principaux changements apportés par F#9 : types de référence annulables, propriétés d'union discriminées .Is*, la mise à jour de la bibliothèque standard (FSharp.Core). F# 9 apporte également des améliorations de la productivité des développeurs ainsi que les performances.F# est un langage de programmation fonctionnel, impératif et orienté objet pour la plate-forme .NET. F# est développé par Microsoft Research et son noyau est dérivé du langage OCaml, avec lequel il est fortement compatible. Ces deux langages de programmation font partie de la même famille que les langages ML. Depuis novembre 2010, Microsoft a mis à la disposition de tous les bibliothèques core et son compilateur F#, sous la licence Apache 22.
F# 9 est disponible et introduit une série d'améliorations pour rendre les programmes plus sûrs, plus résistants et plus performants. F# 9 est disponible dans .NET 9. Voici les principaux changements apportés par F# 9 :
- Types de référence annulables
- Propriétés d'union discriminées .Is*
- Les motifs actifs partiels peuvent renvoyer une option bool au lieu d'une option unit
- Mises à jour de la bibliothèque standard (FSharp.Core)
- Amélioration de la productivité des développeurs
- Amélioration des performances
Types de référence nullables
Bien que F# soit conçu pour éviter null, celles-ci peuvent se glisser dans les interfaces avec les bibliothèques .NET écrites en C#. F# fournit désormais un moyen sûr de traiter les types de référence qui peuvent avoir null comme valeur valide.
Voici quelques exemples :
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | // Declared type at let-binding
let notAValue: string | null = null
let isAValue: string | null = "hello world"
let isNotAValue2: string = null // gives a nullability warning
let getLength (x: string | null) = x.Length // gives a nullability warning since x is a nullable string
// Parameter to a function
let len (str: string | null) =
match str with
| null -> -1
| NonNull s -> s.Length // binds a non-null result
// Parameter to a function
let len (str: string | null) =
let s = nullArgCheck "str" str // Returns a non-null string
s.Length // binds a non-null result
// Declared type at let-binding
let maybeAValue: string | null = hopefullyGetAString()
// Array type signature
let f (arr: (string | null)[]) = ()
// Generic code, note 'T must be constrained to be a reference type
let findOrNull (index: int) (list: 'T list) : 'T | null when 'T : not struct =
match List.tryItem index list with
| Some item -> item
| None -> null |
Propriétés .Is* de l'union discriminée
Les unions discriminées ont désormais des propriétés auto-générées pour chaque cas, ce qui permet de vérifier si une valeur appartient à un cas particulier. Par exemple, pour le type suivant :
| Code : | Sélectionner tout |
1 2 3 4 5 | type Contact =
| Email of address: string
| Phone of countryCode: int * number: string
type Person = { name: string; contact: Contact } |
| Code : | Sélectionner tout |
1 2 3 4 | let canSendEmailTo person =
match person.contact with
| Email _ -> true
| _ -> false |
| Code : | Sélectionner tout |
1 2 | let canSendEmailTo person =
person.contact.IsEmail |
Les motifs actifs partiels peuvent renvoyer bool au lieu de unit option
Auparavant, les motifs actifs partiels renvoyaient Some () pour indiquer une correspondance et None dans le cas contraire. Désormais, ils peuvent également renvoyer bool.
Par exemple, le motif actif pour ce qui suit :
| Code : | Sélectionner tout |
1 2 3 | match key with | CaseInsensitive "foo" -> ... | CaseInsensitive "bar" -> ... |
| Code : | Sélectionner tout |
1 2 3 4 5 | let (|CaseInsensitive|_|) (pattern: string) (value: string) =
if String.Equals(value, pattern, StringComparison.OrdinalIgnoreCase) then
Some ()
else
None |
| Code : | Sélectionner tout |
1 2 | let (|CaseInsensitive|_|) (pattern: string) (value: string) =
String.Equals(value, pattern, StringComparison.OrdinalIgnoreCase) |
Mises à jour de la bibliothèque standard (FSharp.Core)
Fonctions aléatoires pour les collections
Les modules List, Array et Seq disposent de nouvelles fonctions d'échantillonnage et de mélange aléatoires. Cela facilite l'utilisation de F# pour la science des données, l'apprentissage automatique, le développement de jeux et d'autres scénarios où l'aléatoire est nécessaire.
Toutes les fonctions ont les variantes suivantes :
- ...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.
