mixin o rasgo en F #

Question

¿Hay alguna manera de lograr un mixin en Ruby o un rasgo en Scala en F #?

Lo que quiero es básicamente copiar un módulo en otro para que comparta la funcionalidad de los otros módulos, pero se cierra para su modificación. O bien, una forma de pensar de OOP, quiero herencia múltiple, excepto que el objeto principal no se puede modificar.

Answer 1

Usted puede abusar inline y miembros de las restricciones para realizar pato tipeo, que le brinda algunos de los beneficios de mixins. Por ejemplo, se podría traducir este código Ruby (tomado de this tutorial):

module Debug 
    def whoAmI? 
    "#{self.type.name} (\##{self.id}): #{self.to_s}" 
    end 
end 
class Phonograph 
    include Debug 
    # ... 
end 
class EightTrack 
    include Debug 
    # ... 
end 
ph = Phonograph.new("West End Blues") 
et = EightTrack.new("Surrealistic Pillow") 
ph.whoAmI? » "Phonograph (#537766170): West End Blues" 
et.whoAmI? » "EightTrack (#537765860): Surrealistic Pillow" 

a esto:

type Phonograph(id, name) = 
    member x.Id : int = id 
    override x.ToString() = name 

type EightTrack(id, name) = 
    member x.Id : int = id 
    override x.ToString() = name 

module Debug = 
    let inline whoAmI x = 
    sprintf "%s (%d) : %s" 
     (^T : (member GetType : unit -> Type) x).Name 
     (^T : (member Id : int with get) x) 
     (^T : (member ToString : unit -> string) x) 

let ph = Phonograph(537766170, "West End Blues") 
let et = EightTrack(537765860, "Surrealistic Pillow") 

Debug.whoAmI ph //"Phonograph (537766170) : West End Blues" 
Debug.whoAmI et //"EightTrack (537765860) : Surrealistic Pillow" 

Tiene la ventaja (discutible) sobre los métodos de extensión de no requerir una clase de base común o interfaz. Con respecto a su pregunta anterior sobre la palabra clave open, podría tener varios módulos que definan whoAmI y el último open ed sombreará los anteriores. De esa manera puede ordenar de alguna manera "qué tipo de módulo" desea. La biblioteca central F # usa un enfoque similar con checked operators.

Answer 2

Ruby mixins se emula mejor con métodos de extensión (extensiones de tipo) en .NET framework. No creo que F # tenga características de lenguaje especiales que se asemejen más a mixins, rasgos o herencia múltiple.

Ver esta pregunta: How do I create an extension method (F#)?

Y esta descripción: http://msdn.microsoft.com/en-us/library/dd233211.aspx

Por el amor de velocidad, aquí está el ejemplo dado en MSDN:

module MyModule1 = 

    // Define a type. 
    type MyClass() = 
     member this.F() = 100 

    // Define type extension. 
    type MyClass with 
     member this.G() = 200 

module MyModule2 = 
    let function1 (obj1: MyModule1.MyClass) = 
     // Call an ordinary method. 
     printfn "%d" (obj1.F()) 
     // Call the extension method. 
     printfn "%d" (obj1.G())