F#
Extensions de type et de module

Remarques

Ajout de nouvelles méthodes / propriétés aux types existants

F # permet d'ajouter des fonctions en tant que "membres" aux types lorsqu'ils sont définis (par exemple, Types d'enregistrement ). Cependant, F # permet également d'ajouter de nouveaux membres d'instance aux types existants , même ceux déclarés ailleurs et dans d'autres langues .net.

L'exemple suivant ajoute une nouvelle méthode d'instance Duplicate à toutes les instances de String .

type System.String with
    member this.Duplicate times = 
        Array.init times (fun _ -> this)

Remarque : this s'agit d'un nom de variable choisi arbitrairement pour désigner l'instance du type en cours d'extension - x fonctionnerait tout aussi bien, mais serait peut-être moins auto-descriptif.

Il peut alors être appelé de la manière suivante.

// F#-style call
let result1 = "Hi there!".Duplicate 3

// C#-style call
let result2 = "Hi there!".Duplicate(3)

// Both result in three "Hi there!" strings in an array

Cette fonctionnalité est très similaire aux méthodes d'extension en C #.

De nouvelles propriétés peuvent également être ajoutées aux types existants de la même manière. Ils deviendront automatiquement des propriétés si le nouveau membre ne prend aucun argument.

type System.String with
    member this.WordCount =
        ' ' // Space character
        |> Array.singleton
        |> fun xs -> this.Split(xs, StringSplitOptions.RemoveEmptyEntries)
        |> Array.length

let result = "This is an example".WordCount
// result is 4

Ajout de nouvelles fonctions statiques aux types existants

F # permet d'étendre les types existants avec de nouvelles fonctions statiques.

type System.String with
    static member EqualsCaseInsensitive (a, b) = String.Equals(a, b, StringComparison.OrdinalIgnoreCase)

Cette nouvelle fonction peut être appelée comme ceci:

let x = String.EqualsCaseInsensitive("abc", "aBc")
// result is True

Cette fonctionnalité peut signifier qu'au lieu de créer des bibliothèques de fonctions "utilitaires", elles peuvent être ajoutées aux types existants pertinents. Cela peut être utile pour créer plus de versions faciles à utiliser des fonctions permettant le curry .

type System.String with
    static member AreEqual comparer a b = System.String.Equals(a, b, comparer)

let caseInsensitiveEquals = String.AreEqual StringComparison.OrdinalIgnoreCase

let result = caseInsensitiveEquals "abc" "aBc"
// result is True

Ajout de nouvelles fonctions aux modules et types existants à l'aide de modules

Les modules peuvent être utilisés pour ajouter de nouvelles fonctions aux modules et aux types existants.

namespace FSharp.Collections

module List =
    let pair item1 item2 = [ item1; item2 ]

La nouvelle fonction peut alors être appelée comme si elle était un membre original de List.

open FSharp.Collections    

module Testing =
    let result = List.pair "a" "b"
    // result is a list containing "a" and "b"