Make constructors backwards compatible and throw error on vcat.

Author: darsnack

src/onehot.jl

@@ -5,16 +5,16 @@ struct OneHotArray{T<:Integer, L, N, var"N+1", I<:Union{T, AbstractArray{T, N}}}
   indices::I
 end
 OneHotArray{T, L, N, I}(indices) where {T, L, N, I} = OneHotArray{T, L, N, N+1, I}(indices)
-OneHotArray(L::Integer, indices::T) where {T<:Integer} = OneHotArray{T, L, 0, T}(indices)
-OneHotArray(L::Integer, indices::AbstractArray{T, N}) where {T, N} = OneHotArray{T, L, N, typeof(indices)}(indices)
+OneHotArray(indices::T, L::Integer) where {T<:Integer} = OneHotArray{T, L, 0, T}(indices)
+OneHotArray(indices::AbstractArray{T, N}, L::Integer) where {T, N} = OneHotArray{T, L, N, typeof(indices)}(indices)
 
 _indices(x::OneHotArray) = x.indices
 
 const OneHotVector{T, L} = OneHotArray{T, L, 0, 1, T}
 const OneHotMatrix{T, L, I} = OneHotArray{T, L, 1, 2, I}
 
-OneHotVector(L, idx) = OneHotArray(L, idx)
-OneHotMatrix(L, indices) = OneHotArray(L, indices)
+OneHotVector(idx, L) = OneHotArray(idx, L)
+OneHotMatrix(indices, L) = OneHotArray(indices, L)
 
 Base.size(x::OneHotArray{<:Any, L}) where L = (Int(L), size(x.indices)...)
 
@@ -24,7 +24,7 @@ Base.getindex(x::OneHotVector, i::Integer) = _onehotindex(x.indices, i)
 Base.getindex(x::OneHotVector{T, L}, ::Colon) where {T, L} = x
 
 Base.getindex(x::OneHotArray, i::Integer, I...) = _onehotindex.(x.indices[I...], i)
-Base.getindex(x::OneHotArray{<:Any, L}, ::Colon, I...) where L = OneHotArray(L, x.indices[I...])
+Base.getindex(x::OneHotArray{<:Any, L}, ::Colon, I...) where L = OneHotArray(x.indices[I...], L)
 Base.getindex(x::OneHotArray{<:Any, <:Any, <:Any, N}, ::Vararg{Colon, N}) where N = x
 Base.getindex(x::OneHotArray, I::CartesianIndex{N}) where N = x[I[1], Tuple(I)[2:N]...]
 
@@ -33,23 +33,23 @@ _onehot_bool_type(x::OneHotArray{<:Any, <:Any, <:Any, N, <:CuArray}) where N = C
 
 function Base.cat(xs::OneHotArray{<:Any, L}...; dims::Int) where L
   if isone(dims)
-    return cat(map(x -> convert(_onehot_bool_type(x), x), xs)...; dims = 1)
+    return throw(ArgumentError("Cannot concat OneHotArray along first dimension. Use collect to convert to Bool array first."))
   else
-    return OneHotArray(L, cat(_indices.(xs)...; dims = dims - 1))
+    return OneHotArray(cat(_indices.(xs)...; dims = dims - 1), L)
   end
 end
 
 Base.hcat(xs::OneHotArray...) = cat(xs...; dims = 2)
 Base.vcat(xs::OneHotArray...) = cat(xs...; dims = 1)
 
 Base.reshape(x::OneHotArray{<:Any, L}, dims::Dims) where L =
-  (first(dims) == L) ? OneHotArray(L, reshape(x.indices, dims[2:end]...)) :
+  (first(dims) == L) ? OneHotArray(reshape(x.indices, dims[2:end]...), L) :
                        throw(ArgumentError("Cannot reshape OneHotArray if first(dims) != size(x, 1)"))
 Base._reshape(x::OneHotArray, dims::Tuple{Vararg{Int}}) = reshape(x, dims)
 
-batch(xs::AbstractArray{<:OneHotVector{<:Any, L}}) where L = OneHotArray(L, _indices.(xs))
+batch(xs::AbstractArray{<:OneHotVector{<:Any, L}}) where L = OneHotArray(_indices.(xs), L)
 
-Adapt.adapt_structure(T, x::OneHotArray{<:Any, L}) where L = OneHotArray(L, adapt(T, x.indices))
+Adapt.adapt_structure(T, x::OneHotArray{<:Any, L}) where L = OneHotArray(adapt(T, x.indices), L)
 
 Base.BroadcastStyle(::Type{<:OneHotArray{<:Any, <:Any, <:Any, N, <:CuArray}}) where N = CUDA.CuArrayStyle{N}()
 

test/onehot.jl

@@ -27,8 +27,8 @@ end
 
 @testset "abstractmatrix onehotvector multiplication" begin
   A = [1 3 5; 2 4 6; 3 6 9]
-  b1 = Flux.OneHotVector{eltype(A), 3}(1)
-  b2 = Flux.OneHotVector{eltype(A), 5}(3)
+  b1 = Flux.OneHotVector(1, 3)
+  b2 = Flux.OneHotVector(3, 5)
 
   @test A*b1 == A[:,1]
   @test_throws DimensionMismatch A*b2
@@ -37,9 +37,9 @@ end
 @testset "OneHotArray" begin
   using Flux: OneHotArray, OneHotVector, OneHotMatrix
 
-  ov = OneHotVector(10, rand(1:10))
-  om = OneHotMatrix(10, rand(1:10, 5))
-  oa = OneHotArray(10, rand(1:10, 5, 5))
+  ov = OneHotVector(rand(1:10), 10)
+  om = OneHotMatrix(rand(1:10, 5), 10)
+  oa = OneHotArray(rand(1:10, 5, 5), 10)
 
   # sizes
   @testset "Base.size" begin
@@ -55,16 +55,16 @@ end
 
     # matrix indexing
     @test om[3, 3] == (om.indices[3] == 3)
-    @test om[:, 3] == OneHotVector(10, om.indices[3])
+    @test om[:, 3] == OneHotVector(om.indices[3], 10)
     @test om[3, :] == (om.indices .== 3)
     @test om[:, :] == om
 
     # array indexing
     @test oa[3, 3, 3] == (oa.indices[3, 3] == 3)
-    @test oa[:, 3, 3] == OneHotVector(10, oa.indices[3, 3])
+    @test oa[:, 3, 3] == OneHotVector(oa.indices[3, 3], 10)
     @test oa[3, :, 3] == (oa.indices[:, 3] .== 3)
     @test oa[3, :, :] == (oa.indices .== 3)
-    @test oa[:, 3, :] == OneHotMatrix(10, oa.indices[3, :])
+    @test oa[:, 3, :] == OneHotMatrix(oa.indices[3, :], 10)
     @test oa[:, :, :] == oa
 
     # cartesian indexing
@@ -73,18 +73,18 @@ end
 
   @testset "Concatenating" begin
     # vector cat
-    @test hcat(ov, ov) == OneHotMatrix(10, vcat(ov.indices, ov.indices))
-    @test vcat(ov, ov) == vcat(convert(Array{Bool}, ov), convert(Array{Bool}, ov))
-    @test cat(ov, ov; dims = 3) == OneHotArray(10, cat(ov.indices, ov.indices; dims = 2))
+    @test hcat(ov, ov) == OneHotMatrix(vcat(ov.indices, ov.indices), 10)
+    @test_throws ArgumentError vcat(ov, ov)
+    @test cat(ov, ov; dims = 3) == OneHotArray(cat(ov.indices, ov.indices; dims = 2), 10)
 
     # matrix cat
-    @test hcat(om, om) == OneHotMatrix(10, vcat(om.indices, om.indices))
-    @test vcat(om, om) == vcat(convert(Array{Bool}, om), convert(Array{Bool}, om))
-    @test cat(om, om; dims = 3) == OneHotArray(10, cat(om.indices, om.indices; dims = 2))
+    @test hcat(om, om) == OneHotMatrix(vcat(om.indices, om.indices), 10)
+    @test_throws ArgumentError vcat(om, om)
+    @test cat(om, om; dims = 3) == OneHotArray(cat(om.indices, om.indices; dims = 2), 10)
 
     # array cat
-    @test cat(oa, oa; dims = 3) == OneHotArray(10, cat(oa.indices, oa.indices; dims = 2))
-    @test cat(oa, oa; dims = 1) == cat(convert(Array{Bool}, oa), convert(Array{Bool}, oa); dims = 1)
+    @test cat(oa, oa; dims = 3) == OneHotArray(cat(oa.indices, oa.indices; dims = 2), 10)
+    @test_throws ArgumentError cat(oa, oa; dims = 1)
   end
 
   @testset "Base.reshape" begin