Wie richtig überschreiben ich ein eingeschränktes Verfahren

Question

Wie ich die Methode Zero in dem folgenden Code in einer solchen Art und Weise tun außer Kraft setzen, die ich Euro(0) für die Definiton in der type Euro

[<AbstractClass>] 
type Currency() = 
    abstract member Zero<'T when 'T :> Currency > : unit -> 'T 

type Euro (value: int) = 
    inherit Currency() 
    member this.Value = value 
    override this.Zero() = Euro(0) :> _ 

Answer 1

Haben Sie heben versucht, die generische zurückgeben Einschränkung auf Klassenebene?

[<AbstractClass>] 
type Currency<'T when 'T :> Currency<'T>>() = 
    abstract member Zero : unit -> 'T 

type Euro (value: int) = 
    inherit Currency<Euro>() 
    member this.Value = value 
    override this.Zero() = Euro(0) 

Obwohl sich selbst verweisende Generika immer seltsam mir scheint, dies ist, wie es in getan werden würde, beispielsweise C#.

Answer 2

In F # gibt es auch die Methode "Roll your own typeclass". Grundsätzlich werden die Member (Members und Static) des abstrakten Typs die Felder eines 'typeclass'-Records und die Werte dieses Records sind typeclass-Instanzen. Sie können einen ‚Euro‘ Instanz, einen ‚Dollar‘ So und so weiter:

module Currency = 
    type t<[<Measure>] 'a> = 
    { zero : decimal<'a>; from : decimal -> decimal<'a> } 

    /// Helper function to easily create typeclass instances for any 
    /// currency. 
    let make<[<Measure>] 'a> (curr_unit : decimal<'a>) : t<'a> = 
    { zero = curr_unit - curr_unit; from = ((*) curr_unit) } 

    [<Measure>] type euro 
    let euro : t<euro> = make 1m<euro> 

    [<Measure>] type dollar 
    let dollar : t<dollar> = make 1m<dollar> 

Das Besondere an F # ist, dass der Typ-Parameter, die tatsächlich auf jede typeclass Instanz übergeben wird, kann ein Maß Typ sein, was für Währungen angemessen ist.