F#
Typ- und Modulerweiterungen

Bemerkungen

Hinzufügen neuer Methoden / Eigenschaften zu vorhandenen Typen

Mit F # können Funktionen zu Typen als "Mitglieder" hinzugefügt werden, wenn sie definiert werden (z. B. Datensatztypen ). Mit F # können jedoch auch neue Instanzmitglieder zu bereits vorhandenen Typen hinzugefügt werden - auch solche, die an anderer Stelle und in anderen .net-Sprachen deklariert sind.

Im folgenden Beispiel wird allen Instanzen von String eine neue Instanzmethode Duplicate String .

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

Hinweis : this ist ein willkürlich gewählter Variablenname, der verwendet wird, um auf die Instanz des Typs zu verweisen, der erweitert wird - x würde genauso gut funktionieren, wäre aber vielleicht weniger selbstbeschreibend.

Es kann dann auf folgende Weise aufgerufen werden.

// 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

Diese Funktionalität ist den Erweiterungsmethoden in C # sehr ähnlich.

Neue Eigenschaften können auf dieselbe Weise zu vorhandenen Typen hinzugefügt werden. Sie werden automatisch zu Eigenschaften, wenn das neue Mitglied keine Argumente akzeptiert.

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

Hinzufügen neuer statischer Funktionen zu vorhandenen Typen

Mit F # können vorhandene Typen mit neuen statischen Funktionen erweitert werden.

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

Diese neue Funktion kann wie folgt aufgerufen werden:

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

Diese Funktion kann bedeuten, dass Bibliotheken mit Funktionen nicht mehr erstellt werden müssen, sondern sie zu relevanten vorhandenen Typen hinzugefügt werden können. Dies kann nützlich sein, um weitere F # -freundliche Versionen von Funktionen zu erstellen, die Funktionen wie das Currying ermöglichen .

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

Hinzufügen von neuen Funktionen zu vorhandenen Modulen und Typen mithilfe von Modulen

Module können verwendet werden, um vorhandenen Modulen und Typen neue Funktionen hinzuzufügen.

namespace FSharp.Collections

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

Die neue Funktion kann dann aufgerufen werden, als wäre sie ein ursprüngliches Mitglied von List.

open FSharp.Collections    

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