Constructor and convertor clean.

With `construct_type`, there's no need to keep all these dispatches.

This change also makes it easier to distinguish `SVector{1}(1， 2)` and `SVector{1}((1, 2))` (The former should be disallowed)

Also fix empty construction for `S/MVector`.

Author: N5N3

src/MArray.jl

@@ -20,42 +20,23 @@ the compiler (the element type may optionally also be specified).
 mutable struct MArray{S <: Tuple, T, N, L} <: StaticArray{S, T, N}
     data::NTuple{L,T}
 
-    function MArray{S,T,N,L}(x::NTuple{L,T}) where {S,T,N,L}
+    function MArray{S,T,N,L}(x::NTuple{L,T}) where {S<:Tuple,T,N,L}
         check_array_parameters(S, T, Val{N}, Val{L})
         new{S,T,N,L}(x)
     end
 
-    function MArray{S,T,N,L}(x::NTuple{L,Any}) where {S,T,N,L}
+    function MArray{S,T,N,L}(x::NTuple{L,Any}) where {S<:Tuple,T,N,L}
         check_array_parameters(S, T, Val{N}, Val{L})
         new{S,T,N,L}(convert_ntuple(T, x))
     end
 
-    function MArray{S,T,N,L}(::UndefInitializer) where {S,T,N,L}
+    function MArray{S,T,N,L}(::UndefInitializer) where {S<:Tuple,T,N,L}
         check_array_parameters(S, T, Val{N}, Val{L})
         new{S,T,N,L}()
     end
 end
 
-@generated function (::Type{MArray{S,T,N}})(x::Tuple) where {S,T,N}
-    return quote
-        $(Expr(:meta, :inline))
-        MArray{S,T,N,$(tuple_prod(S))}(x)
-    end
-end
-
-@generated function (::Type{MArray{S,T}})(x::Tuple) where {S,T}
-    return quote
-        $(Expr(:meta, :inline))
-        MArray{S,T,$(tuple_length(S)),$(tuple_prod(S))}(x)
-    end
-end
-
-@generated function (::Type{MArray{S}})(x::T) where {S, T <: Tuple}
-    return quote
-        $(Expr(:meta, :inline))
-        MArray{S,promote_tuple_eltype(T),$(tuple_length(S)),$(tuple_prod(S))}(x)
-    end
-end
+@inline MArray{S,T,N}(x::Tuple) where {S<:Tuple,T,N} = MArray{S,T,N,length(x)}(x)
 
 @generated function (::Type{MArray{S,T,N}})(::UndefInitializer) where {S,T,N}
     return quote
@@ -71,8 +52,6 @@ end
     end
 end
 
-@inline MArray(a::StaticArray{S,T}) where {S<:Tuple,T} = MArray{S,T}(Tuple(a))
-
 ####################
 ## MArray methods ##
 ####################

src/MMatrix.jl

@@ -17,43 +17,13 @@ unknown to the compiler (the element type may optionally also be specified).
 """
 const MMatrix{S1, S2, T, L} = MArray{Tuple{S1, S2}, T, 2, L}
 
-@generated function (::Type{MMatrix{S1}})(x::NTuple{L}) where {S1,L}
-    S2 = div(L, S1)
-    if S1*S2 != L
-        throw(DimensionMismatch("Incorrect matrix sizes. $S1 does not divide $L elements"))
-    end
-    return quote
-        $(Expr(:meta, :inline))
-        T = eltype(typeof(x))
-        MMatrix{S1, $S2, T, L}(x)
-    end
-end
-
-@generated function (::Type{MMatrix{S1,S2}})(x::NTuple{L}) where {S1,S2,L}
-    return quote
-        $(Expr(:meta, :inline))
-        T = eltype(typeof(x))
-        MMatrix{S1, S2, T, L}(x)
-    end
-end
-
-@generated function (::Type{MMatrix{S1,S2,T}})(x::NTuple{L}) where {S1,S2,T,L}
-    return quote
-        $(Expr(:meta, :inline))
-        MMatrix{S1, S2, T, L}(x)
-    end
-end
-
 @generated function (::Type{MMatrix{S1,S2,T}})(::UndefInitializer) where {S1,S2,T}
     return quote
         $(Expr(:meta, :inline))
         MMatrix{S1, S2, T, $(S1*S2)}(undef)
     end
 end
 
-@inline convert(::Type{MMatrix{S1,S2}}, a::StaticArray{<:Tuple, T}) where {S1,S2,T} = MMatrix{S1,S2,T}(Tuple(a))
-@inline MMatrix(a::StaticMatrix{N,M,T}) where {N,M,T} = MMatrix{N,M,T}(Tuple(a))
-
 # Some more advanced constructor-like functions
 @inline one(::Type{MMatrix{N}}) where {N} = one(MMatrix{N,N})
 

src/MVector.jl

@@ -16,11 +16,6 @@ compiler (the element type may optionally also be specified).
 """
 const MVector{S, T} = MArray{Tuple{S}, T, 1, S}
 
-@inline MVector(a::StaticVector{N,T}) where {N,T} = MVector{N,T}(a)
-@inline MVector(x::NTuple{S,Any}) where {S} = MVector{S}(x)
-@inline MVector{S}(x::NTuple{S,T}) where {S, T} = MVector{S, T}(x)
-@inline MVector{S}(x::NTuple{S,Any}) where {S} = MVector{S, promote_tuple_eltype(typeof(x))}(x)
-
 # Some more advanced constructor-like functions
 @inline zeros(::Type{MVector{N}}) where {N} = zeros(MVector{N,Float64})
 @inline ones(::Type{MVector{N}}) where {N} = ones(MVector{N,Float64})

src/SArray.jl

@@ -18,38 +18,18 @@ compiler (the element type may optionally also be specified).
 struct SArray{S <: Tuple, T, N, L} <: StaticArray{S, T, N}
     data::NTuple{L,T}
 
-    function SArray{S, T, N, L}(x::NTuple{L,T}) where {S, T, N, L}
+    function SArray{S, T, N, L}(x::NTuple{L,T}) where {S<:Tuple, T, N, L}
         check_array_parameters(S, T, Val{N}, Val{L})
         new{S, T, N, L}(x)
     end
 
-    function SArray{S, T, N, L}(x::NTuple{L,Any}) where {S, T, N, L}
+    function SArray{S, T, N, L}(x::NTuple{L,Any}) where {S<:Tuple, T, N, L}
         check_array_parameters(S, T, Val{N}, Val{L})
         new{S, T, N, L}(convert_ntuple(T, x))
     end
 end
 
-@generated function (::Type{SArray{S, T, N}})(x::Tuple) where {S <: Tuple, T, N}
-    return quote
-        @_inline_meta
-        SArray{S, T, N, $(tuple_prod(S))}(x)
-    end
-end
-
-@generated function (::Type{SArray{S, T}})(x::Tuple) where {S <: Tuple, T}
-    return quote
-        @_inline_meta
-        SArray{S, T, $(tuple_length(S)), $(tuple_prod(S))}(x)
-    end
-end
-
-@generated function (::Type{SArray{S}})(x::T) where {S <: Tuple, T <: Tuple}
-    return quote
-        @_inline_meta
-        SArray{S, promote_tuple_eltype(T), $(tuple_length(S)), $(tuple_prod(S))}(x)
-    end
-end
-
+@inline SArray{S,T,N}(x::Tuple) where {S<:Tuple,T,N} = SArray{S,T,N,length(x)}(x)
 
 @noinline function generator_too_short_error(inds::CartesianIndices, i::CartesianIndex)
     error("Generator produced too few elements: Expected exactly $(shape_string(inds)) elements, but generator stopped at $(shape_string(i))")
@@ -106,8 +86,6 @@ sacollect
 @inline (::Type{SA})(gen::Base.Generator) where {SA <: StaticArray} =
     sacollect(SA, gen)
 
-@inline SArray(a::StaticArray{S,T}) where {S<:Tuple,T} = SArray{S,T}(Tuple(a))
-
 ####################
 ## SArray methods ##
 ####################

src/SHermitianCompact.jl

@@ -60,6 +60,7 @@ lowertriangletype(::Type{SHermitianCompact{N}}) where {N} = SVector{triangularnu
 end
 
 @generated function SHermitianCompact{N, T, L}(a::Tuple) where {N, T, L}
+    _check_hermitian_parameters(Val(N), Val(L))
     expr = Vector{Expr}(undef, L)
     i = 0
     for col = 1 : N, row = col : N
@@ -77,15 +78,13 @@ end
     SHermitianCompact{N, T, L}(a)
 end
 
-@inline SHermitianCompact{N}(a::Tuple) where {N} = SHermitianCompact{N, promote_tuple_eltype(a)}(a)
-@inline SHermitianCompact{N}(a::NTuple{M, T}) where {N, T, M} = SHermitianCompact{N, T}(a)
-@inline SHermitianCompact(a::StaticMatrix{N, N, T}) where {N, T} = SHermitianCompact{N, T}(a)
-
 @inline (::Type{SSC})(a::SHermitianCompact) where {SSC <: SHermitianCompact} = SSC(a.lowertriangle)
-@inline (::Type{SSC})(a::SSC) where {SSC <: SHermitianCompact} = a
 
 @inline (::Type{SSC})(a::AbstractVector) where {SSC <: SHermitianCompact} = SSC(convert(lowertriangletype(SSC), a))
 
+# disambiguation
+@inline (::Type{SSC})(a::StaticArray{<:Tuple,<:Any,1}) where {SSC <: SHermitianCompact} = SSC(convert(SVector, a))
+
 @generated function _hermitian_compact_indices(::Val{N}) where N
     # Returns a Tuple{Pair{Int, Bool}} I such that for linear index i,
     # * I[i][1] is the index into the lowertriangle field of an SHermitianCompact{N};

src/SMatrix.jl

@@ -16,50 +16,11 @@ unknown to the compiler (the element type may optionally also be specified).
 """
 const SMatrix{S1, S2, T, L} = SArray{Tuple{S1, S2}, T, 2, L}
 
-@generated function SMatrix{S1}(x::NTuple{L,Any}) where {S1,L}
-    S2 = div(L, S1)
-    if S1*S2 != L
-        throw(DimensionMismatch("Incorrect matrix sizes. $S1 does not divide $L elements"))
-    end
-
-    return quote
-        $(Expr(:meta, :inline))
-        T = promote_tuple_eltype(typeof(x))
-        SMatrix{S1, $S2, T, L}(x)
-    end
-end
-
-@generated function SMatrix{S1,S2}(x::NTuple{L,Any}) where {S1,S2,L}
-    return quote
-        $(Expr(:meta, :inline))
-        T = promote_tuple_eltype(typeof(x))
-        SMatrix{S1, S2, T, L}(x)
-    end
-end
-SMatrixNoType{S1, S2, L, T} = SMatrix{S1, S2, T, L}
-@generated function SMatrixNoType{S1, S2, L}(x::NTuple{L,Any}) where {S1,S2,L}
-    return quote
-        $(Expr(:meta, :inline))
-        T = promote_tuple_eltype(typeof(x))
-        SMatrix{S1, S2, T, L}(x)
-    end
-end
-
-@generated function SMatrix{S1,S2,T}(x::NTuple{L,Any}) where {S1,S2,T,L}
-    return quote
-        $(Expr(:meta, :inline))
-        SMatrix{S1, S2, T, L}(x)
-    end
-end
-
 @inline SMatrix{M, N, T}(gen::Base.Generator) where {M, N, T} =
     sacollect(SMatrix{M, N, T}, gen)
 @inline SMatrix{M, N}(gen::Base.Generator) where {M, N} =
     sacollect(SMatrix{M, N}, gen)
 
-@inline convert(::Type{SMatrix{S1,S2}}, a::StaticArray{<:Tuple, T}) where {S1,S2,T} = SMatrix{S1,S2,T}(Tuple(a))
-@inline SMatrix(a::StaticMatrix{S1, S2, T}) where {S1, S2, T} = SMatrix{S1, S2, T}(Tuple(a))
-
 # Some more advanced constructor-like functions
 @inline one(::Type{SMatrix{N}}) where {N} = one(SMatrix{N,N})
 

src/SVector.jl

@@ -15,11 +15,6 @@ compiler (the element type may optionally also be specified).
 """
 const SVector{S, T} = SArray{Tuple{S}, T, 1, S}
 
-@inline SVector(a::StaticVector{N,T}) where {N,T} = SVector{N,T}(a)
-@inline SVector(x::NTuple{S,Any}) where {S} = SVector{S}(x)
-@inline SVector{S}(x::NTuple{S,T}) where {S, T} = SVector{S,T}(x)
-@inline SVector{S}(x::T) where {S, T <: Tuple} = SVector{S,promote_tuple_eltype(T)}(x)
-
 @inline SVector{N, T}(gen::Base.Generator) where {N, T} =
     sacollect(SVector{N, T}, gen)
 @inline SVector{N}(gen::Base.Generator) where {N} =

src/Scalar.jl

@@ -6,13 +6,14 @@ Construct a statically-sized 0-dimensional array that contains a single element,
 """
 const Scalar{T} = SArray{Tuple{},T,0,1}
 
-@inline Scalar(x::Tuple{T}) where {T} = Scalar{T}(x[1])
 @inline Scalar(a::AbstractArray) = Scalar{typeof(a)}((a,))
+@inline Scalar(a::StaticArray) = Scalar{typeof(a)}((a,)) # disambiguation
+
 @inline Scalar(a::AbstractScalar) = Scalar{eltype(a)}((a[],)) # Do we want this to convert or wrap?
-@inline function convert(::Type{SA}, a::AbstractArray) where {SA <: Scalar}
-    return SA((a[],))
-end
-@inline convert(::Type{SA}, sa::SA) where {SA <: Scalar} = sa
+@inline Scalar(a::StaticScalar) = Scalar{eltype(a)}((a[],)) # disambiguation
+
+@inline convert(::Type{SA}, a::AbstractArray) where {SA <: Scalar} = SA((a[],))
+@inline convert(::Type{SA}, sa::StaticArray) where {SA <: Scalar} = SA((sa[],)) # disambiguation
 
 @propagate_inbounds function getindex(v::Scalar, i::Int)
     @boundscheck if i != 1