Upgrade to FunctionImplementations.jl v0.4

Project.toml

@@ -1,7 +1,7 @@
 name = "SparseArraysBase"
 uuid = "0d5efcca-f356-4864-8770-e1ed8d78f208"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
-version = "0.8.4"
+version = "0.9.0"
 
 [deps]
 Accessors = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"
@@ -31,7 +31,7 @@ Adapt = "4.3"
 ArrayLayouts = "1.11"
 Dictionaries = "0.4.3"
 FillArrays = "1.13"
-FunctionImplementations = "0.3.1"
+FunctionImplementations = "0.4"
 GPUArraysCore = "0.2"
 LinearAlgebra = "1.10"
 MapBroadcast = "0.1.5"

docs/Project.toml

@@ -11,4 +11,4 @@ SparseArraysBase = {path = ".."}
 Dictionaries = "0.4.4"
 Documenter = "1.8.1"
 Literate = "2.20.1"
-SparseArraysBase = "0.8"
+SparseArraysBase = "0.9"

examples/Project.toml

@@ -8,5 +8,5 @@ SparseArraysBase = {path = ".."}
 
 [compat]
 Dictionaries = "0.4.4"
-SparseArraysBase = "0.8"
+SparseArraysBase = "0.9"
 Test = "<0.0.1, 1"

src/abstractsparsearray.jl

@@ -24,7 +24,8 @@ const AnyAbstractSparseVecOrMat{T} = Union{
 Base.convert(T::Type{<:AbstractSparseArray}, a::AbstractArray) = a isa T ? a : T(a)
 
 using FunctionImplementations: FunctionImplementations
-FunctionImplementations.Style(::Type{<:AnyAbstractSparseArray}) = SparseArrayStyle()
+FunctionImplementations.ImplementationStyle(::Type{<:AnyAbstractSparseArray}) =
+    SparseArrayImplementationStyle()
 
 function Base.copy(a::AnyAbstractSparseArray)
     return copyto!(similar(a), a)
@@ -102,7 +103,7 @@ function LinearAlgebra.mul!(
 end
 
 function Base.Broadcast.BroadcastStyle(type::Type{<:AnyAbstractSparseArray})
-    return Broadcast.SparseArrayStyle{ndims(type)}()
+    return SparseArrayStyle{ndims(type)}()
 end
 
 using ArrayLayouts: ArrayLayouts

src/abstractsparsearraystyle.jl

@@ -51,26 +51,30 @@ function dense(a::AbstractArray)
     return @allowscalar convert(densetype(a), a)
 end
 
-# Minimal interface for `SparseArrayStyle`.
+# Minimal interface for `SparseArrayImplementationStyle`.
 # Fallbacks for dense/non-sparse arrays.
 
-using FunctionImplementations: AbstractArrayStyle
-abstract type AbstractSparseArrayStyle <: AbstractArrayStyle end
+using FunctionImplementations: AbstractArrayImplementationStyle
+abstract type AbstractSparseArrayImplementationStyle <: AbstractArrayImplementationStyle end
 
-function FunctionImplementations.Style(
-        style1::AbstractSparseArrayStyle, style2::AbstractSparseArrayStyle
+function FunctionImplementations.ImplementationStyle(
+        style1::AbstractSparseArrayImplementationStyle,
+        style2::AbstractSparseArrayImplementationStyle,
     )
-    return SparseArrayStyle()
+    return SparseArrayImplementationStyle()
 end
-function FunctionImplementations.Style(
-        style1::AbstractSparseArrayStyle, style2::AbstractArrayStyle
+function FunctionImplementations.ImplementationStyle(
+        style1::AbstractSparseArrayImplementationStyle,
+        style2::AbstractArrayImplementationStyle,
     )
     return style1
 end
-# Fix ambiguity error with `Style(::AbstractSparseArrayStyle, ::AbstractArrayStyle)`.
-using FunctionImplementations: DefaultArrayStyle
-function FunctionImplementations.Style(
-        style1::AbstractSparseArrayStyle, style2::DefaultArrayStyle
+# Fix ambiguity error with
+# `ImplementationStyle(::AbstractSparseArrayImplementationStyle, ::AbstractArrayImplementationStyle)`.
+using FunctionImplementations: DefaultArrayImplementationStyle
+function FunctionImplementations.ImplementationStyle(
+        style1::AbstractSparseArrayImplementationStyle,
+        style2::DefaultArrayImplementationStyle,
     )
     return style1
 end

src/sparsearraystyle.jl

@@ -1,12 +1,12 @@
 using FunctionImplementations: FunctionImplementations
 
-struct SparseArrayStyle <: AbstractSparseArrayStyle end
+struct SparseArrayImplementationStyle <: AbstractSparseArrayImplementationStyle end
 
 # Convenient shorthand to refer to the sparse style.
 # Can turn a function into a sparse function with the syntax `sparse_style(f)`,
 # i.e. `sparse_style(map)(x -> 2x, randn(2, 2))` while use the sparse
 # version of `map`.
-const sparse_style = SparseArrayStyle()
+const sparse_style = SparseArrayImplementationStyle()
 
 const fill!_sparse = sparse_style(fill!)
 function fill!_sparse(a::AbstractArray, value)
@@ -78,27 +78,23 @@ function mapreduce_sparse(
     return output
 end
 
-# Namespace for Broadcast styles to avoid clashing with FunctionImplementations
-# styles.
-module Broadcast
-    abstract type AbstractSparseArrayStyle{N} <: Base.Broadcast.AbstractArrayStyle{N} end
-    struct SparseArrayStyle{N} <: AbstractSparseArrayStyle{N} end
-    SparseArrayStyle{M}(::Val{N}) where {M, N} = SparseArrayStyle{N}()
-end
+abstract type AbstractSparseArrayStyle{N} <: Base.Broadcast.AbstractArrayStyle{N} end
+struct SparseArrayStyle{N} <: AbstractSparseArrayStyle{N} end
+SparseArrayStyle{M}(::Val{N}) where {M, N} = SparseArrayStyle{N}()
 
 using MapBroadcast: Mapped
 # TODO: Look into `SparseArrays.capturescalars`:
 # https://github.com/JuliaSparse/SparseArrays.jl/blob/1beb0e4a4618b0399907b0000c43d9f66d34accc/src/higherorderfns.jl#L1092-L1102
 function Base.copyto!(
-        a_dest::AbstractArray, bc::Base.Broadcast.Broadcasted{<:Broadcast.SparseArrayStyle}
+        a_dest::AbstractArray, bc::Base.Broadcast.Broadcasted{<:SparseArrayStyle}
     )
     m = Mapped(bc)
     map!(m.f, a_dest, m.args...)
     return a_dest
 end
 
 function Base.similar(
-        bc::Base.Broadcast.Broadcasted{<:Broadcast.SparseArrayStyle}, elt::Type, ax
+        bc::Base.Broadcast.Broadcasted{<:SparseArrayStyle}, elt::Type, ax
     )
     return similar(SparseArrayDOK{elt}, ax)
 end

src/wrappers.jl

@@ -190,9 +190,9 @@ for type in (:Adjoint, :PermutedDimsArray, :ReshapedArray, :SubArray, :Transpose
     end
 end
 
-using FunctionImplementations: Style
+using FunctionImplementations: ImplementationStyle
 using LinearAlgebra: LinearAlgebra, Diagonal
-const diag_style = Style(Diagonal)
+const diag_style = ImplementationStyle(Diagonal)
 const storedvalues_diag = diag_style(storedvalues)
 storedvalues_diag(D::AbstractMatrix) = LinearAlgebra.diag(D)
 

test/Project.toml

@@ -26,14 +26,14 @@ Aqua = "0.8.11"
 ArrayLayouts = "1.11.1"
 Dictionaries = "0.4.4"
 FillArrays = "1.13.0"
-FunctionImplementations = "0.3"
+FunctionImplementations = "0.4"
 JLArrays = "0.2.0, 0.3"
 LinearAlgebra = "<0.0.1, 1"
 NamedDimsArrays = "0.13"
 Random = "<0.0.1, 1"
 SafeTestsets = "0.1.0"
 SparseArrays = "1.10"
-SparseArraysBase = "0.8"
+SparseArraysBase = "0.9"
 StableRNGs = "1.0.2"
 Suppressor = "0.2.8"
 TensorAlgebra = "0.6"

test/test_sparse_style.jl

@@ -1,34 +1,37 @@
-using FunctionImplementations: DefaultArrayStyle, Style, style
-using SparseArraysBase: AbstractSparseArrayStyle, SparseArrayStyle, sparse_style,
-    sparsezeros
+using FunctionImplementations: DefaultArrayImplementationStyle, ImplementationStyle, style
+using SparseArraysBase: AbstractSparseArrayImplementationStyle,
+    SparseArrayImplementationStyle, sparse_style, sparsezeros
 using Test: @test, @testset
 
-module TestSparseStyleUtils
-    using SparseArraysBase: AbstractSparseArray, AbstractSparseArrayStyle
+module TestSparseImplementationStyleUtils
+    using SparseArraysBase: AbstractSparseArray, AbstractSparseArrayImplementationStyle
     using FunctionImplementations: FunctionImplementations
-    struct MySparseArrayStyle <: AbstractSparseArrayStyle end
+    struct MySparseArrayImplementationStyle <: AbstractSparseArrayImplementationStyle end
     struct MySparseArray{T, N} <: AbstractSparseArray{T, N}
         size::NTuple{N, Int}
     end
-    FunctionImplementations.Style(::Type{<:MySparseArray}) = MySparseArrayStyle()
+    FunctionImplementations.ImplementationStyle(::Type{<:MySparseArray}) =
+        MySparseArrayImplementationStyle()
 end
 
 @testset "Combine Sparse Styles" begin
-    @test sparse_style ≡ SparseArrayStyle()
-    @test Style(SparseArrayStyle(), SparseArrayStyle()) ≡ SparseArrayStyle()
-    @test Style(TestSparseStyleUtils.MySparseArrayStyle(), SparseArrayStyle()) ≡
-        SparseArrayStyle()
-    @test Style(SparseArrayStyle(), TestSparseStyleUtils.MySparseArrayStyle()) ≡
-        SparseArrayStyle()
-    @test style(TestSparseStyleUtils.MySparseArray{Float64, 2}((2, 2))) ≡
-        TestSparseStyleUtils.MySparseArrayStyle()
-    @test style(sparsezeros(2, 2), TestSparseStyleUtils.MySparseArray{Float64, 2}((2, 2))) ≡
-        SparseArrayStyle()
-
+    @test sparse_style ≡ SparseArrayImplementationStyle()
+    @test ImplementationStyle(SparseArrayImplementationStyle(), SparseArrayImplementationStyle()) ≡ SparseArrayImplementationStyle()
+    @test ImplementationStyle(TestSparseImplementationStyleUtils.MySparseArrayImplementationStyle(), SparseArrayImplementationStyle()) ≡
+        SparseArrayImplementationStyle()
+    @test ImplementationStyle(SparseArrayImplementationStyle(), TestSparseImplementationStyleUtils.MySparseArrayImplementationStyle()) ≡
+        SparseArrayImplementationStyle()
+    @test style(TestSparseImplementationStyleUtils.MySparseArray{Float64, 2}((2, 2))) ≡
+        TestSparseImplementationStyleUtils.MySparseArrayImplementationStyle()
+    @test style(sparsezeros(2, 2), TestSparseImplementationStyleUtils.MySparseArray{Float64, 2}((2, 2))) ≡
+        SparseArrayImplementationStyle()
     # Regression tests for ambiguity caused by combining AbstractSparseArrayStyle with
     # DefaultArrayStyle.
-    @test Style(TestSparseStyleUtils.MySparseArrayStyle(), DefaultArrayStyle()) ≡
-        TestSparseStyleUtils.MySparseArrayStyle()
-    @test style(TestSparseStyleUtils.MySparseArray{Float64, 2}((2, 2)), randn(2, 2)) ≡
-        TestSparseStyleUtils.MySparseArrayStyle()
+    @test ImplementationStyle(
+        TestSparseImplementationStyleUtils.MySparseArrayImplementationStyle(),
+        DefaultArrayImplementationStyle(),
+    ) ≡
+        TestSparseImplementationStyleUtils.MySparseArrayImplementationStyle()
+    @test style(TestSparseImplementationStyleUtils.MySparseArray{Float64, 2}((2, 2)), randn(2, 2)) ≡
+        TestSparseImplementationStyleUtils.MySparseArrayImplementationStyle()
 end