Resolve merge conflicts

Author: mtfishman

Project.toml

@@ -31,7 +31,7 @@ Adapt = "4.1.1"
 Aqua = "0.8.9"
 ArrayLayouts = "1.10.4"
 BlockArrays = "1.2.0"
-DerivableInterfaces = "0.4"
+DerivableInterfaces = "0.5"
 DiagonalArrays = "0.3"
 Dictionaries = "0.4.3"
 FillArrays = "1.13.0"

src/blocksparsearrayinterface/blocksparsearrayinterface.jl

@@ -102,24 +102,37 @@ blockstype(a::BlockArray) = blockstype(typeof(a))
 blocktype(arraytype::Type{<:BlockArray}) = eltype(blockstype(arraytype))
 blocktype(a::BlockArray) = eltype(blocks(a))
 
-abstract type AbstractBlockSparseArrayInterface <: AbstractSparseArrayInterface end
+abstract type AbstractBlockSparseArrayInterface{N} <: AbstractSparseArrayInterface{N} end
 
 # TODO: Also support specifying the `blocktype` along with the `eltype`.
-function DerivableInterfaces.arraytype(
-  interface::AbstractBlockSparseArrayInterface, T::Type
-)
-  B = DerivableInterfaces.arraytype(interface.blockinterface, T)
-  return BlockSparseArray{T,<:Any,B}
+function Base.similar(interface::AbstractBlockSparseArrayInterface, T::Type, ax::Tuple)
+  N = length(ax)
+  block_axt = Tuple{blockaxistype.(ax)...}
+  B = _similartype(blockinterface(interface), Type{T}, block_axt)
+  return similar(BlockSparseArray{T,N,B}, ax)
 end
 
-struct BlockSparseArrayInterface{B<:AbstractArrayInterface} <:
-       AbstractBlockSparseArrayInterface
+struct BlockSparseArrayInterface{N,B<:AbstractArrayInterface{N}} <:
+       AbstractBlockSparseArrayInterface{N}
   blockinterface::B
 end
+blockinterface(interface::BlockSparseArrayInterface) = getfield(interface, :blockinterface)
+function BlockSparseArrayInterface{N}(blockinterface::AbstractArrayInterface{N}) where {N}
+  return BlockSparseArrayInterface{N,typeof(blockinterface)}(blockinterface)
+end
+function BlockSparseArrayInterface{N}() where {N}
+  return BlockSparseArrayInterface{N}(DefaultArrayInterface{N}())
+end
+BlockSparseArrayInterface(::Val{N}) where {N} = BlockSparseArrayInterface{N}()
+BlockSparseArrayInterface{M}(::Val{N}) where {M,N} = BlockSparseArrayInterface{N}()
+function BlockSparseArrayInterface{M,B}(::Val{N}) where {M,B<:AbstractArrayInterface{M},N}
+  return BlockSparseArrayInterface{N,B}(B(Val(N)))
+end
+BlockSparseArrayInterface() = BlockSparseArrayInterface{Any}()
 
-@interface ::AbstractBlockSparseArrayInterface BlockArrays.blocks(a::AbstractArray) = error(
-  "Not implemented"
-)
+@interface ::AbstractBlockSparseArrayInterface function BlockArrays.blocks(a::AbstractArray)
+  return error("Not implemented")
+end
 
 @interface ::AbstractBlockSparseArrayInterface function SparseArraysBase.isstored(
   a::AbstractArray{<:Any,N}, I::Vararg{Int,N}

src/blocksparsearrayinterface/broadcast.jl

@@ -24,6 +24,7 @@ end
 #   return BlockSparseArrayStyle{ndims(arraytype)}()
 # end
 
+BlockSparseArrayStyle{N}() where {N} = BlockSparseArrayStyle{N}(DefaultArrayStyle{N}())
 BlockSparseArrayStyle(::Val{N}) where {N} = BlockSparseArrayStyle{N}()
 BlockSparseArrayStyle{M}(::Val{N}) where {M,N} = BlockSparseArrayStyle{N}()