F#
Extensiones de Tipo y Módulo

Observaciones

Agregando nuevos métodos / propiedades a los tipos existentes

F # permite que las funciones se agreguen como "miembros" a los tipos cuando se definen (por ejemplo, Tipos de registro ). Sin embargo, F # también permite agregar nuevos miembros de instancia a los tipos existentes , incluso los declarados en otros lugares y en otros idiomas .net.

El siguiente ejemplo agrega un nuevo método de instancia Duplicate a todas las instancias de String .

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

Nota : this es un nombre de variable elegido arbitrariamente para usar para referirse a la instancia del tipo que se está extendiendo: x funcionaría igual de bien, pero quizás sea menos autodeclarado.

Entonces se puede llamar de las siguientes maneras.

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

Esta funcionalidad es muy similar a los métodos de extensión en C #.

Las nuevas propiedades también se pueden agregar a los tipos existentes de la misma manera. Se convertirán automáticamente en propiedades si el nuevo miembro no toma argumentos.

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

Añadiendo nuevas funciones estáticas a los tipos existentes.

F # permite que los tipos existentes se amplíen con nuevas funciones estáticas.

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

Esta nueva función se puede invocar así:

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

Esta característica puede significar que, en lugar de tener que crear bibliotecas de funciones "de utilidad", se pueden agregar a los tipos existentes relevantes. Esto puede ser útil para crear más versiones amigables con F # de funciones que permitan funciones como el 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

Agregar nuevas funciones a los módulos y tipos existentes usando módulos

Los módulos se pueden usar para agregar nuevas funciones a los módulos y tipos existentes.

namespace FSharp.Collections

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

La nueva función se puede llamar como si fuera un miembro original de la Lista.

open FSharp.Collections    

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