Tipo de herança em F #

Question

Não consigo encontrar a sintaxe adequada para a codificação de um tipo D que herda uma classe base B (escrito em C #) e seus construtores que não o construtor implícito classe base:

C # código:

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;
    }
}

F # código:

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

Graças

Answer 1

Eu encontrei uma maneira de fazê-lo graças este blogue !

type D =
    class
        inherit B

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

Sim, é um pouco complicado, mas como Brian disse que não é a maioria dos casos.

EDIT: Na verdade, palavras-chave de classe / finais não são obrigatórios para que (assim que eu retiro o que eu disse sobre cumbersomeness). Como Brian disse em seu blog aqui , F # normalmente infere a tipo de tipo que está sendo definido, tornando esses tokens desnecessário / redundante.

type D =
    inherit B

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

Answer 2

De docs: "Os argumentos para o construtor da classe base aparecem na lista de argumentos na cláusula herdar." Por exemplo:

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

Eu não tenho certeza se você pode chamar diferentes construtores da classe base a partir de diferentes # construtores F, porque F # exige que todos os construtores para percorrer o construtor "primário" (porque os argumentos do construtor primários estão no escopo para toda a classe, para que eles tenham para ser inicializado). No seu caso, você pode sair com ele porque sua classe base tem um construtor máxima:

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

Mas para uma classe base sem um construtor máxima não estou certo de que este é possível.