Posso costruire un costruttore senza parametri per un tipo parametrico in un costruttore esterno?

Question

Per istanziare un tipo come x = MyType{Int}()

Posso definire un costruttore interno.

immutable MyType{T} 
    x::Vector{T} 

    MyType() = new(T[]) 
end 

È possibile raggiungere lo stesso obiettivo utilizzando un costruttore esterno?

Answer 1

questo può essere fatto utilizzando la seguente sintassi:

(::Type{MyType{T}}){T}() = MyType{T}(T[]) 

La cosa nel primo set di parentesi descrive l'oggetto chiamato. ::T significa "di tipo T", quindi questa è una definizione per chiamare un oggetto di tipo Type{MyType{T}}, che significa l'oggetto MyType{T} stesso. Il prossimo {T} significa che T è un parametro di questa definizione e che un valore deve essere disponibile per chiamare questa definizione. Quindi corrispondenze MyType{Int}, ma non lo è lo MyType. Da lì in poi, la sintassi dovrebbe essere familiare.

Questa sintassi è decisamente un po 'complicata e non intuitiva, e speriamo di migliorarla in una versione futura della lingua, si spera v0.6.

Answer 2

I può essere sbagliato, ma se non si può costruire funzione senza parametri in questo modo:

julia> f{T}() = show(T) 
WARNING: static parameter T does not occur in signature for f at none:1. 
The method will not be callable. 
f (generic function with 1 method) 

quindi non sarà in grado di fare questo:

julia> immutable MyType{T} 
      x::Vector{T} 
     end 

julia> MyType{T}() = MyType{T}(T[]) 
WARNING: static parameter T does not occur in signature for call at none:1. 
The method will not be callable. 
MyType{T} 

julia> x = MyType{Int}() 
ERROR: MethodError: `convert` has no method matching convert(::Type{MyType{Int64}}) 
... 

Ogni costruttore esterno è anche un funzione.

Answer 3

Si può dire

f(T::Type) = show(T) 

e anche

MyType(T::Type) = MyType(T[]) 

Ma Julia ha bisogno di vedere il tipo nella chiamata a sapere che si desidera.