update to ArrayInterface v7

Author: ChrisRackauckas

Project.toml

@@ -5,8 +5,7 @@ version = "2.37.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
-ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
-ArrayInterfaceStaticArraysCore = "dd5226c6-a4d4-4bc7-8575-46859f9c95b9"
+ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
@@ -23,8 +22,7 @@ ZygoteRules = "700de1a5-db45-46bc-99cf-38207098b444"
 
 [compat]
 Adapt = "3"
-ArrayInterfaceCore = "0.1.1"
-ArrayInterfaceStaticArraysCore = "0.1"
+ArrayInterface = "7"
 ChainRulesCore = "0.10.7, 1"
 DocStringExtensions = "0.8, 0.9"
 FillArrays = "0.11, 0.12, 0.13"

src/RecursiveArrayTools.jl

@@ -6,18 +6,13 @@ module RecursiveArrayTools
 
 using DocStringExtensions
 using RecipesBase, StaticArraysCore, Statistics,
-      ArrayInterfaceCore, LinearAlgebra
+      ArrayInterface, LinearAlgebra
 using SymbolicIndexingInterface
 
 import ChainRulesCore
 import ChainRulesCore: NoTangent
 import ZygoteRules, Adapt
 
-# Required for the downstream_events.jl test
-# Since `ismutable` on an ArrayPartition needs
-# to know static arrays are not mutable
-import ArrayInterfaceStaticArraysCore
-
 using FillArrays
 
 import Tables, IteratorInterfaceExtensions

src/array_partition.jl

@@ -114,9 +114,9 @@ end
 Base.ones(A::ArrayPartition, dims::NTuple{N, Int}) where {N} = ones(A)
 
 # mutable iff all components of ArrayPartition are mutable
-@generated function ArrayInterfaceCore.ismutable(::Type{<:ArrayPartition{T, S}}) where {T, S
+@generated function ArrayInterface.ismutable(::Type{<:ArrayPartition{T, S}}) where {T, S
                                                                                         }
-    res = all(ArrayInterfaceCore.ismutable, S.parameters)
+    res = all(ArrayInterface.ismutable, S.parameters)
     return :($res)
 end
 
@@ -429,7 +429,7 @@ end
 
 ## Linear Algebra
 
-ArrayInterfaceCore.zeromatrix(A::ArrayPartition) = ArrayInterfaceCore.zeromatrix(Vector(A))
+ArrayInterface.zeromatrix(A::ArrayPartition) = ArrayInterface.zeromatrix(Vector(A))
 
 function LinearAlgebra.ldiv!(A::Factorization, b::ArrayPartition)
     (x = ldiv!(A, Array(b)); copyto!(b, x))

src/utils.jl

@@ -18,11 +18,11 @@ function recursivecopy(a::AbstractArray{T, N}) where {T <: Number, N}
 end
 
 function recursivecopy(a::AbstractArray{T, N}) where {T <: AbstractArray, N}
-    if ArrayInterfaceCore.ismutable(a)
+    if ArrayInterface.ismutable(a)
         b = similar(a)
         map!(recursivecopy, b, a)
     else
-        ArrayInterfaceCore.restructure(a, map(recursivecopy, a))
+        ArrayInterface.restructure(a, map(recursivecopy, a))
     end
 end
 
@@ -59,7 +59,7 @@ end
 function recursivecopy!(b::AbstractArray{T, N},
                         a::AbstractArray{T2, N}) where {T <: AbstractArray,
                                                         T2 <: AbstractArray, N}
-    if ArrayInterfaceCore.ismutable(T)
+    if ArrayInterface.ismutable(T)
         @inbounds for i in eachindex(b, a)
             recursivecopy!(b[i], a[i])
         end
@@ -166,7 +166,7 @@ If `i<length(x)`, it's simply a `recursivecopy!` to the `i`th element. Otherwise
 """
 function copyat_or_push!(a::AbstractVector{T}, i::Int, x, perform_copy = true) where {T}
     @inbounds if length(a) >= i
-        if !ArrayInterfaceCore.ismutable(T) || !perform_copy
+        if !ArrayInterface.ismutable(T) || !perform_copy
             # TODO: Check for `setindex!`` if T <: StaticArraysCore.StaticArray and use `copy!(b[i],a[i])`
             #       or `b[i] = a[i]`, see https://github.com/JuliaDiffEq/RecursiveArrayTools.jl/issues/19
             a[i] = x