Simplified the Size trait

Author: Andy Ferris

src/StaticArrays.jl

@@ -13,7 +13,7 @@ export Scalar, SArray, SVector, SMatrix
 export MArray, MVector, MMatrix
 export FieldVector, MutableFieldVector
 
-export Size, SizeOf
+export Size
 
 export @SVector, @SMatrix, @SArray
 export @MVector, @MMatrix, @MArray

src/det.jl

@@ -1,25 +1,25 @@
-@inline det(A::StaticMatrix) = det(SizeOf(A), A)
+@inline det(A::StaticMatrix) = _det(Size(A), A)
 
 """
     det(Size(m,m), mat)
 
 Calculate the matrix determinate using an algorithm specialized on the size of
 the `m`×`m` matrix `mat`, which is much faster for small matrices.
 """
-@inline det(::Type{Size{(1,1)}}, A::AbstractMatrix) = @inbounds return A[1]
+@inline _det(::Size{(1,1)}, A::AbstractMatrix) = @inbounds return A[1]
 
-@inline function det(::Type{Size{(2,2)}}, A::AbstractMatrix)
+@inline function _det(::Size{(2,2)}, A::AbstractMatrix)
     @inbounds return A[1]*A[4] - A[3]*A[2]
 end
 
-@inline function det(::Type{Size{(3,3)}}, A::AbstractMatrix)
+@inline function _det(::Size{(3,3)}, A::AbstractMatrix)
     @inbounds x0 = SVector(A[1], A[2], A[3])
     @inbounds x1 = SVector(A[4], A[5], A[6])
     @inbounds x2 = SVector(A[7], A[8], A[9])
     return vecdot(x0, cross(x1, x2))
 end
 
-@generated function det{S,T}(::Type{Size{S}}, A::AbstractMatrix{T})
+@generated function _det{S,T}(::Size{S}, A::AbstractMatrix{T})
     if S[1] != S[2]
         throw(DimensionMismatch("matrix is not square"))
     end

src/traits.jl

@@ -1,70 +1,48 @@
 """
-    SizeOf(static_array)
-
-Returns the size of a static array, wrapped in a `Size` trait such as
-`Size{(2,3)}` for a 2×3 matrix.
+    Size(static_array)
+    Size(StaticArrayType)
+    Size(dims...)
 
-`SizeOf` implements the "traitor" paradigm for traits, whereby an abstract trait
-class `SizeOf` returns a direct subtype, in this case `Size`.
+A trait type allowing convenient trait-based dispatch on the size of a statically
+sized array. The dimensions are stored as a type parameter and are statically
+propagated by the compiler.
 
 For example,
 ```
-det(x::StaticMatrix) = det(SizeOf(x), x)
-det(::Type{Size{1,1}}, x::AbstractMatrix) = x[1,1]
-det(::Type{Size{2,2}}, x::AbstractMatrix) = x[1,1]*x[2,2] - x[1,2]*x[2,1]
+det(x::StaticMatrix) = _det(Size(x), x)
+_det(::Size{(1,1)}, x::StaticMatrix) = x[1,1]
+_det(::Size{(2,2)}, x::StaticMatrix) = x[1,1]*x[2,2] - x[1,2]*x[2,1]
 # and other definitions as necessary
 ```
 """
-abstract SizeOf
+immutable Size{S}
+    function Size()
+        check_size(S)
+        new()
+    end
+end
 
+@pure check_size(S::Tuple{Vararg{Int}}) = nothing
+check_size(S) = error("Size was expected to be a tuple of `Int`s")
 
-"""
-    Size{(dims...)} <: SizeOf
-
-A trait type allowing convenient trait-based dispatch on the size of a statically
-sized array.
+@pure Size{SA<:StaticArray}(::Type{SA}) = Size{size(SA)}()
+@inline Size(a::StaticArray) = Size(typeof(a))
 
-`Size` implements the "traitor" paradigm for traits, whereby an abstract trait
-class `SizeOf` returns a direct subtype, in this case `Size`.
+@pure Size(s::Tuple{Vararg{Int}}) = Size{s}()
+@pure Size(s::Int...) = Size{s}()
 
-For example,
-```
-det(x::StaticMatrix) = det(SizeOf(x), x)
-det(::Type{Size{1,1}}, x::AbstractMatrix) = x[1,1]
-det(::Type{Size{2,2}}, x::AbstractMatrix) = x[1,1]*x[2,2] - x[1,2]*x[2,1]
-# and other definitions as necessary
-```
-"""
-immutable Size{S} <: SizeOf
-end
+Base.show{S}(io::IO, ::Size{S}) = print(io, "Size", S)
 
-@pure SizeOf{SA<:StaticArray}(::Type{SA}) = Size{size(SA)}
-@inline SizeOf(a::StaticArray) = Size(typeof(a))
 
-# Also define these, since may be more convenient than SizeOf
-"""
-    Size(static_array)
-    Size(StaticArrayType)
+# Some @pure convenience functions.
 
-Convenience constructor for the `Size` of a static array. See also `SizeOf`.
-"""
-@pure Size{SA<:StaticArray}(::Type{SA}) = Size{size(SA)}
-@inline Size(a::StaticArray) = Size(typeof(a))
+# (This type could *probably* be returned from the `size()` function.
+# This might enable some generic programming, e.g. with `similar(A, size(A))`.)
 
-"""
-    Size((dims...))
-    Size(dims...)
+@pure getindex{S}(::Size{S}, i::Int) = S[i]
 
-Pure function that constructs a compile-time constant `Size` of an array. This
-allows for dispatch of standard (dynamically-sized) arrays to faster, specialized
-*StaticArrays* library methods when the programmer knows or can reasonably infer
-the size. For example,
-```
-mat = [1.0 2.0; 3.0 4.0]
-det(Size(2,2), mat)  # Faster than det(mat)
-```
-"""
-@pure Size(s::Tuple{Vararg{Int}}) = Size{s}
-@pure Size(s::Int...) = Size{s}
+@pure Base.:(==){S}(::Size{S}, s::Tuple{Vararg{Int}}) = S == s
+@pure Base.:(==){S}(s::Tuple{Vararg{Int}}, ::Size{S}) = s == S
 
-@pure getindex{S}(::Type{Size{S}}, i::Int) = S[i]
+@pure Base.:(!=){S}(::Size{S}, s::Tuple{Vararg{Int}}) = S != s
+@pure Base.:(!=){S}(s::Tuple{Vararg{Int}}, ::Size{S}) = s != S