Delete Broadcast module

Author: mtfishman

src/abstractblocksparsearray/broadcast.jl

@@ -2,7 +2,7 @@ using BlockArrays: AbstractBlockedUnitRange, BlockSlice
 using Base.Broadcast: BroadcastStyle
 
 function Base.Broadcast.BroadcastStyle(arraytype::Type{<:AnyAbstractBlockSparseArray})
-    return Broadcast.BlockSparseArrayStyle(BroadcastStyle(blocktype(arraytype)))
+    return BlockSparseArrayStyle(BroadcastStyle(blocktype(arraytype)))
 end
 
 # Fix ambiguity error with `BlockArrays`.
@@ -16,7 +16,7 @@ function Base.Broadcast.BroadcastStyle(
             },
         },
     )
-    return Broadcast.BlockSparseArrayStyle{ndims(arraytype)}()
+    return BlockSparseArrayStyle{ndims(arraytype)}()
 end
 function Base.Broadcast.BroadcastStyle(
         arraytype::Type{
@@ -32,7 +32,7 @@ function Base.Broadcast.BroadcastStyle(
             },
         },
     )
-    return Broadcast.BlockSparseArrayStyle{ndims(arraytype)}()
+    return BlockSparseArrayStyle{ndims(arraytype)}()
 end
 function Base.Broadcast.BroadcastStyle(
         arraytype::Type{
@@ -44,7 +44,7 @@ function Base.Broadcast.BroadcastStyle(
             },
         },
     )
-    return Broadcast.BlockSparseArrayStyle{ndims(arraytype)}()
+    return BlockSparseArrayStyle{ndims(arraytype)}()
 end
 
 # These catch cases that aren't caught by the standard
@@ -59,7 +59,7 @@ function Base.copyto!(
     return copyto!_blocksparse(dest, bc)
 end
 function Base.copyto!(
-        dest::AnyAbstractBlockSparseArray{<:Any, N}, bc::Broadcasted{<:Broadcast.BlockSparseArrayStyle{N}}
+        dest::AnyAbstractBlockSparseArray{<:Any, N}, bc::Broadcasted{<:BlockSparseArrayStyle{N}}
     ) where {N}
     return copyto!_blocksparse(dest, bc)
 end

src/blocksparsearrayinterface/broadcast.jl

@@ -2,57 +2,55 @@ using Base.Broadcast: BroadcastStyle, Broadcasted
 using GPUArraysCore: @allowscalar
 using MapBroadcast: Mapped
 
-module Broadcast
-    using Base.Broadcast: AbstractArrayStyle
-    abstract type AbstractBlockSparseArrayStyle{N, B <: AbstractArrayStyle{N}} <:
-    AbstractArrayStyle{N} end
-    struct BlockSparseArrayStyle{N, B <: AbstractArrayStyle{N}} <:
-        AbstractBlockSparseArrayStyle{N, B}
-        blockstyle::B
-    end
-    function BlockSparseArrayStyle{N}(blockstyle::AbstractArrayStyle{N}) where {N}
-        return BlockSparseArrayStyle{N, typeof(blockstyle)}(blockstyle)
-    end
-    function BlockSparseArrayStyle{N, B}() where {N, B <: AbstractArrayStyle{N}}
-        return BlockSparseArrayStyle{N, B}(B())
-    end
-    function BlockSparseArrayStyle{N}() where {N}
-        return BlockSparseArrayStyle{N}(Base.Broadcast.DefaultArrayStyle{N}())
-    end
-    BlockSparseArrayStyle(::Val{N}) where {N} = BlockSparseArrayStyle{N}()
-    BlockSparseArrayStyle{M}(::Val{N}) where {M, N} = BlockSparseArrayStyle{N}()
-    function BlockSparseArrayStyle{M, B}(::Val{N}) where {M, B <: AbstractArrayStyle{M}, N}
-        return BlockSparseArrayStyle{N}(B(Val(N)))
-    end
+using Base.Broadcast: AbstractArrayStyle
+abstract type AbstractBlockSparseArrayStyle{N, B <: AbstractArrayStyle{N}} <:
+AbstractArrayStyle{N} end
+struct BlockSparseArrayStyle{N, B <: AbstractArrayStyle{N}} <:
+    AbstractBlockSparseArrayStyle{N, B}
+    blockstyle::B
+end
+function BlockSparseArrayStyle{N}(blockstyle::AbstractArrayStyle{N}) where {N}
+    return BlockSparseArrayStyle{N, typeof(blockstyle)}(blockstyle)
+end
+function BlockSparseArrayStyle{N, B}() where {N, B <: AbstractArrayStyle{N}}
+    return BlockSparseArrayStyle{N, B}(B())
+end
+function BlockSparseArrayStyle{N}() where {N}
+    return BlockSparseArrayStyle{N}(Base.Broadcast.DefaultArrayStyle{N}())
+end
+BlockSparseArrayStyle(::Val{N}) where {N} = BlockSparseArrayStyle{N}()
+BlockSparseArrayStyle{M}(::Val{N}) where {M, N} = BlockSparseArrayStyle{N}()
+function BlockSparseArrayStyle{M, B}(::Val{N}) where {M, B <: AbstractArrayStyle{M}, N}
+    return BlockSparseArrayStyle{N}(B(Val(N)))
 end
 
 function blockstyle(
-        ::Broadcast.AbstractBlockSparseArrayStyle{N, B},
+        ::AbstractBlockSparseArrayStyle{N, B},
     ) where {N, B <: Base.Broadcast.AbstractArrayStyle{N}}
     return B()
 end
 
 function Base.Broadcast.BroadcastStyle(
-        style1::Broadcast.AbstractBlockSparseArrayStyle,
-        style2::Broadcast.AbstractBlockSparseArrayStyle,
+        style1::AbstractBlockSparseArrayStyle,
+        style2::AbstractBlockSparseArrayStyle,
     )
     style = Base.Broadcast.result_style(blockstyle(style1), blockstyle(style2))
-    return Broadcast.BlockSparseArrayStyle(style)
+    return BlockSparseArrayStyle(style)
 end
 
-Base.Broadcast.BroadcastStyle(a::Broadcast.BlockSparseArrayStyle, ::Base.Broadcast.DefaultArrayStyle{0}) = a
+Base.Broadcast.BroadcastStyle(a::BlockSparseArrayStyle, ::Base.Broadcast.DefaultArrayStyle{0}) = a
 function Base.Broadcast.BroadcastStyle(
-        ::Broadcast.BlockSparseArrayStyle{N}, a::Base.Broadcast.DefaultArrayStyle
+        ::BlockSparseArrayStyle{N}, a::Base.Broadcast.DefaultArrayStyle
     ) where {N}
     return Base.Broadcast.BroadcastStyle(Base.Broadcast.DefaultArrayStyle{N}(), a)
 end
 function Base.Broadcast.BroadcastStyle(
-        ::Broadcast.BlockSparseArrayStyle{N}, ::Base.Broadcast.Style{Tuple}
+        ::BlockSparseArrayStyle{N}, ::Base.Broadcast.Style{Tuple}
     ) where {N}
     return Base.Broadcast.DefaultArrayStyle{N}()
 end
 
-function Base.similar(bc::Broadcasted{<:Broadcast.BlockSparseArrayStyle}, elt::Type, ax)
+function Base.similar(bc::Broadcasted{<:BlockSparseArrayStyle}, elt::Type, ax)
     # Find the first array in the broadcast expression.
     # TODO: Make this more generic, base it off sure this handles GPU arrays properly.
     bc′ = Base.Broadcast.flatten(bc)
@@ -84,7 +82,7 @@ end
 
 # Broadcasting implementation
 function Base.copyto!(
-        dest::AbstractArray{<:Any, N}, bc::Broadcasted{Broadcast.BlockSparseArrayStyle{N}}
+        dest::AbstractArray{<:Any, N}, bc::Broadcasted{BlockSparseArrayStyle{N}}
     ) where {N}
     return copyto!_blocksparse(dest, bc)
 end

src/blocksparsearrayinterface/cat.jl

@@ -2,7 +2,7 @@ using BlockArrays: blocks
 using FunctionImplementations.Concatenate: Concatenated, cat!
 
 function Base.copyto!(
-        dest::AbstractArray, concat::Concatenated{<:Broadcast.BlockSparseArrayStyle}
+        dest::AbstractArray, concat::Concatenated{<:BlockSparseArrayStyle}
     )
     # TODO: This assumes the destination blocking is commensurate with
     # the blocking of the sources, for example because it was constructed