Use ismutable from ArrayInterface and clean up copyat via recursivecopy

Author: ChrisRackauckas

REQUIRE

@@ -2,3 +2,4 @@ julia 1.0
 Requires
 RecipesBase 0.1.0
 StaticArrays
+ArrayInterface 0.1.0

src/RecursiveArrayTools.jl

@@ -2,7 +2,8 @@ __precompile__()
 
 module RecursiveArrayTools
 
-  using Requires, RecipesBase, StaticArrays, Statistics
+  using Requires, RecipesBase, StaticArrays, Statistics,
+        ArrayInterface
 
   abstract type AbstractVectorOfArray{T, N} <: AbstractArray{T, N} end
   abstract type AbstractDiffEqArray{T, N} <: AbstractVectorOfArray{T, N} end

src/array_partition.jl

@@ -186,6 +186,7 @@ function recursivecopy!(A::ArrayPartition, B::ArrayPartition)
     recursivecopy!(a, b)
   end
 end
+recursivecopy(A::ArrayPartition) = ArrayPartition(copy.(A.x))
 
 recursive_mean(A::ArrayPartition) = mean((recursive_mean(x) for x in A.x))
 
@@ -227,7 +228,7 @@ combine_styles(args::Tuple{Any})      = Broadcast.result_style(Broadcast.Broadca
 combine_styles(args::Tuple{Any, Any}) = Broadcast.result_style(Broadcast.BroadcastStyle(args[1]), Broadcast.BroadcastStyle(args[2]))
 @inline combine_styles(args::Tuple)   = Broadcast.result_style(Broadcast.BroadcastStyle(args[1]), combine_styles(Base.tail(args)))
 
-function Broadcast.BroadcastStyle(::Type{ArrayPartition{T,S}}) where {T, S} 
+function Broadcast.BroadcastStyle(::Type{ArrayPartition{T,S}}) where {T, S}
     Style = combine_styles((S.parameters...,))
     ArrayPartitionStyle(Style)
 end
@@ -270,7 +271,7 @@ _npartitions(args::Tuple{}) = 0
 @inline unpack(bc::Broadcast.Broadcasted{ArrayPartitionStyle{Style}}, i) where Style = Broadcast.Broadcasted{Style}(bc.f, unpack_args(i, bc.args))
 unpack(x,::Any) = x
 unpack(x::ArrayPartition, i) = x.x[i]
- 
+
 @inline unpack_args(i, args::Tuple) = (unpack(args[1], i), unpack_args(i, Base.tail(args))...)
 unpack_args(i, args::Tuple{Any}) = (unpack(args[1], i),)
 unpack_args(::Any, args::Tuple{}) = ()

src/utils.jl

@@ -1,17 +1,7 @@
-"""
-    is_mutable_type(x::DataType)
-
-Query whether a type is mutable or not, see
-https://github.com/JuliaDiffEq/RecursiveArrayTools.jl/issues/19.
-"""
-Base.@pure is_mutable_type(x::DataType) = x.mutable
-
 function recursivecopy(a)
   deepcopy(a)
 end
-
-recursivecopy(a::Number) = copy(a)
-
+recursivecopy(a::Union{SVector,SMatrix,SArray,Number}) = copy(a)
 function recursivecopy(a::AbstractArray{T,N}) where {T<:Number,N}
   copy(a)
 end
@@ -66,7 +56,7 @@ end
 
 function copyat_or_push!(a::AbstractVector{T},i::Int,x,nc::Type{Val{perform_copy}}=Val{true}) where {T,perform_copy}
   @inbounds if length(a) >= i
-    if T <: Number || T <: SArray || (T <: FieldVector && !is_mutable_type(T)) || !perform_copy
+    if !ismutable(T) || !perform_copy
       # TODO: Check for `setindex!`` if T <: 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
@@ -75,16 +65,7 @@ function copyat_or_push!(a::AbstractVector{T},i::Int,x,nc::Type{Val{perform_copy
     end
   else
       if perform_copy
-        if typeof(x) <: Array && !(eltype(x) <: Number)
-          push!(a,recursivecopy(x))
-        elseif typeof(x) <: Array || typeof(x) <: ArrayPartition ||
-             typeof(x) <: AbstractVectorOfArray
-          push!(a,copy(x))
-        elseif typeof(x) <: Union{SVector,SMatrix,SArray,Number} # Only immutable
-          push!(a,x)
-        else
-          push!(a,deepcopy(x))
-        end
+        push!(a,recursivecopy(x))
       else
         push!(a,x)
       end

src/vector_of_array.jl

@@ -66,6 +66,7 @@ end
 
 # Tools for creating similar objects
 @inline Base.similar(VA::VectorOfArray, ::Type{T} = eltype(VA)) where {T} = VectorOfArray([similar(VA[i], T) for i in eachindex(VA)])
+recursivecopy(VA::VectorOfArray) = VectorOfArray(copy.(VA.u))
 
 # fill!
 # For DiffEqArray it ignores ts and fills only u