Progress towards new subtype compatibility for v0.6

This addresses some of the worst problems from Jeff's new subtype
algorithm.

Currently a lot of the constructor code is incorrect in this branch.
I'm hoping the new, more consistent subtyping algorithm will help to
acheive what we want, but the horrible hacks for v0.5 are not
forward-compatible.

Author: Andy Ferris

src/FieldVector.jl

@@ -21,8 +21,10 @@ abstract FieldVector{T} <: StaticVector{T}
 # Is this a good idea?? Should people just define constructors that accept tuples?
 @inline (::Type{FV}){FV<:FieldVector}(x::Tuple) = FV(x...)
 
-@pure size{FV<:FieldVector}(::Union{FV,Type{FV}}) = (length(FV.types),)
-@pure length{FV<:FieldVector}(::Union{FV,Type{FV}}) = size(FV)[1]
+@pure size{FV<:FieldVector}(::FV) = (length(FV.types),)
+@pure size{FV<:FieldVector}(::Type{FV}) = (length(FV.types),)
+@pure length{FV<:FieldVector}(::FV) = size(FV)[1]
+@pure length{FV<:FieldVector}(::Type{FV}) = size(FV)[1]
 
 @inline getindex(v::FieldVector, i::Integer) = getfield(v, i)
 @inline setindex!(v::FieldVector, x, i::Integer) = setfield!(v, i, x)

src/FixedSizeArrays.jl

@@ -58,7 +58,9 @@ immutable Point{S, T} <: StaticVector{T}
     data::NTuple{S, T}
 end
 
-@inline (::Type{Point}){S}(x::NTuple{S}) = Point{S}(x)
+if VERSION < v"0.5+"
+    @inline (::Type{Point}){S}(x::NTuple{S}) = Point{S}(x)
+end
 @inline (::Type{Point{S}}){S, T}(x::NTuple{S,T}) = Point{S,T}(x)
 @inline (::Type{Point{S}}){S, T <: Tuple}(x::T) = Point{S,promote_tuple_eltype(T)}(x)
 

src/abstractarray.jl

@@ -1,11 +1,14 @@
 typealias StaticScalar{T} StaticArray{T,0}
 
-@pure length{T<:StaticArray}(a::Union{T,Type{T}}) = prod(size(a))
-@pure length{T<:StaticScalar}(a::Union{T,Type{T}}) = 1
+@pure length{T<:StaticArray}(a::T) = prod(size(a))
+@pure length{T<:StaticArray}(a::Type{T}) = prod(size(a))
+@pure length{T<:StaticScalar}(a::T) = 1
+@pure length{T<:StaticScalar}(a::Type{T}) = 1
 
-@pure function size{T<:StaticArray}(a::Union{T,Type{T}}, d::Integer)
+@pure size{T<:StaticArray}(::T, d::Integer) = size(T, d)
+@pure function size{T<:StaticArray}(a::Type{T}, d::Integer)
     s = size(a)
-    return (d <= length(s) ? s[d] : 1)
+    return d <= length(s) ? s[d] : 1
 end
 
 # This seems to confuse Julia a bit in certain circumstances (specifically for trailing 1's)
@@ -14,7 +17,8 @@ end
     1 <= ii <= length(a) ? true : false
 end
 
-Base.linearindexing{T<:StaticArray}(::Union{T,Type{T}}) = Base.LinearFast()
+Base.linearindexing(::StaticArray) = Base.LinearFast()
+Base.linearindexing{T<:StaticArray}(::Type{T}) = Base.LinearFast()
 
 # Default type search for similar_type
 """

src/arraymath.jl

@@ -69,8 +69,8 @@ Base.promote_op{Op,T<:Number,A<:StaticArray}(op::Op, ::Type{T}, ::Type{A}) = sim
 @inline (|){T}(a1::Number, a2::StaticArray{T}) = broadcast(|, a1, a2)
 @inline ($){T}(a1::Number, a2::StaticArray{T}) = broadcast($, a1, a2)
 
-
-@generated function Base.zeros{SA <: StaticArray}(::Union{SA,Type{SA}})
+@inline zeros{SA <: StaticArray}(::SA) = zeros(SA)
+@generated function Base.zeros{SA <: StaticArray}(::Type{SA})
     s = size(SA)
     T = eltype(SA)
     if T == Any
@@ -82,9 +82,9 @@ Base.promote_op{Op,T<:Number,A<:StaticArray}(op::Op, ::Type{T}, ::Type{A}) = sim
         $(Expr(:call, SA, Expr(:tuple, v...)))
     end
 end
-@inline Base.zero{SA <: StaticArray}(a::Union{SA,Type{SA}}) = zeros(a)
 
-@generated function Base.ones{SA <: StaticArray}(::Union{SA,Type{SA}})
+@inline Base.ones{SA <: StaticArray}(::SA) = ones(SA)
+@generated function Base.ones{SA <: StaticArray}(::Type{SA})
     s = size(SA)
     T = eltype(SA)
     if T == Any
@@ -97,7 +97,8 @@ end
     end
 end
 
-@generated function Base.fill{SA <: StaticArray}(val, ::Union{SA,Type{SA}})
+@inline Base.fill{SA <: StaticArray}(val, ::SA) = fill(val, SA)
+@generated function Base.fill{SA <: StaticArray}(val, ::Type{SA})
     l = length(SA)
     T = eltype(SA)
     expr = [:valT for i = 1:l]

src/linalg.jl

@@ -216,6 +216,9 @@ end
 @inline hcat(a::Union{StaticVector,StaticMatrix}, b::Union{StaticVector,StaticMatrix}, c::Union{StaticVector,StaticMatrix}...) =
     hcat(hcat(a,b), c...)
 
+@inline Base.zero{SA <: StaticArray}(a::SA) = zeros(SA)
+@inline Base.zero{SA <: StaticArray}(a::Type{SA}) = zeros(SA)
+
 @generated function one{SM <: StaticArray}(::Type{SM})
     s = size(SM)
     if (length(s) != 2) || (s[1] != s[2])

src/util.jl

@@ -43,14 +43,16 @@ end
     @inbounds return ntuple(i -> convert(T1,a[i]), Val{N})
 end
 
-# TODO try and make this generate fast code
-@inline convert(::Type{Tuple}, g::Base.Generator) = (g...)
-@inline function convert{N}(::Type{NTuple{N}}, g::Base.Generator)
-    @boundscheck if length(g.iter) != N
-        error("Array of length $(length(a)) cannot be converted to a $N-tuple")
-    end
+if VERSION < v"0.5+"
+    # TODO try and make this generate fast code
+    @inline convert(::Type{Tuple}, g::Base.Generator) = (g...)
+    @inline function convert{N}(::Type{NTuple{N}}, g::Base.Generator)
+        @boundscheck if length(g.iter) != N
+            error("Array of length $(length(a)) cannot be converted to a $N-tuple")
+        end
 
-    @inbounds return ntuple(i -> g.f(g.iter[i]), Val{N})
+        @inbounds return ntuple(i -> g.f(g.iter[i]), Val{N})
+    end
 end
 
 #=