Digitare l'ereditarietà in F #

Question

Non riesco a trovare la sintassi corretta per codificare un tipo D che eredita una classe base B (scritta in C #) e i suoi costruttori diversi dal costruttore implicito della classe base:

Codice C #:

public class B
{
    private int _i;
    private float _f;
    public B()
    {
        _i = 0;
        _f = 0.0f;
    }
    public B(int i)
    {
        _i = 0;
        _f = 0.0f;
    }
    public B(int i, float f)
    {
        _i = i;
        _f = f;
    }
}

Codice F #:

type D() =
    inherit B()
    //how to inherit from other constructors ?

Grazie

Answer 1

Ho trovato un modo per farlo grazie a questo blog !

type D =
    class
        inherit B

        new () = {
            inherit B()
        }
        new (i : int) = {
            inherit B(i)
        }
        new ((i,f) : int*single) = {
            inherit B(i, f)
        }
    end

Sì, è un po 'ingombrante, ma come Brian ha detto che non è la maggior parte dei casi.

EDIT: In realtà, le parole chiave class / end non sono obbligatorie per questo (quindi riprendo ciò che ho detto sull'ingombro). Come ha detto Brian sul suo blog qui , F # normalmente infligge il tipo di tipo che viene definito, rendendo questi token non necessari / ridondanti.

type D =
    inherit B

    new () = {
        inherit B()
    }
    new (i : int) = {
        inherit B(i)
    }
    new ((i,f) : int*single) = {
        inherit B(i, f)
    }

Answer 2

Dai documenti: " Gli argomenti per il costruttore della classe base vengono visualizzati nell'elenco degli argomenti nella clausola eredit. " Ad esempio:

type D(i: int) =
   inherit B(i)

Non sono sicuro di poter chiamare costruttori di classi base differenti da costruttori F # diversi, poiché F # richiede a tutti i costruttori di passare attraverso il "quot" primario " costruttore (poiché gli argomenti del costruttore principale rientrano nell'ambito dell'intera classe, quindi devono essere inizializzati). Nel tuo caso, puoi cavartela perché la tua classe base ha un costruttore massimo:

type D(i : int, f : float) =
  inherit B(i, f)
  new(i : int) = D(i, 0.0)
  new() = D(0, 0.0)

Ma per una classe base senza un costruttore massimo non sono sicuro che ciò sia possibile.