Add CUDA extension to disambiguate CuArray(::AbstractVectorOfArray)

The functor-style `(::Type{<:AbstractGPUArray})(::AbstractVectorOfArray)`
cannot resolve the ambiguity with CUDA's `CuArray(::AbstractArray{T,N})`
because neither method is uniformly more specific (arg1 vs arg2).

Fix: add a CUDA.jl extension that defines the exact disambiguation
Julia requests: `CuArray(::AbstractVectorOfArray{T,N}) where {T,N}`.
This is loaded only when CUDA is available and resolves the ambiguity
by being a direct method on the concrete `CuArray` type.

Uses stack(VA.u) to stay on GPU (avoids GPU→CPU→GPU round-trip).

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ChrisRackauckas

Project.toml

@@ -15,6 +15,7 @@ StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"
 SymbolicIndexingInterface = "2efcf032-c050-4f8e-a9bb-153293bab1f5"
 
 [weakdeps]
+CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
@@ -29,6 +30,7 @@ Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [extensions]
+RecursiveArrayToolsCUDAExt = "CUDA"
 RecursiveArrayToolsFastBroadcastExt = "FastBroadcast"
 RecursiveArrayToolsForwardDiffExt = "ForwardDiff"
 RecursiveArrayToolsKernelAbstractionsExt = "KernelAbstractions"
@@ -46,6 +48,7 @@ RecursiveArrayToolsZygoteExt = "Zygote"
 Adapt = "4"
 Aqua = "0.8"
 ArrayInterface = "7.16"
+CUDA = "5"
 DocStringExtensions = "0.9.3"
 FastBroadcast = "0.3.5"
 ForwardDiff = "0.10.38, 1"

ext/RecursiveArrayToolsCUDAExt.jl

@@ -0,0 +1,13 @@
+module RecursiveArrayToolsCUDAExt
+
+using RecursiveArrayTools: AbstractVectorOfArray
+import CUDA: CuArray
+
+# Disambiguate CuArray(::AbstractVectorOfArray) vs CuArray(::AbstractArray{T,N}) from CUDA.jl.
+# This is the exact signature Julia's ambiguity error requests.
+# Uses stack to stay on GPU (avoids GPU→CPU→GPU round-trip).
+function CuArray(VA::AbstractVectorOfArray{T, N}) where {T, N}
+    return CuArray{T, N}(stack(VA.u))
+end
+
+end

src/RecursiveArrayTools.jl

@@ -176,13 +176,11 @@ module RecursiveArrayTools
     # AbstractVectorOfArray uses AbstractArray's show
 
     import GPUArraysCore
+    # GPU conversion via stack (stays on device, avoids materializing dense Array).
+    # Only define convert — do NOT define a constructor (::Type{<:AbstractGPUArray})(::AbstractVectorOfArray)
+    # because it creates an unresolvable ambiguity with CUDA.jl's CuArray(::AbstractArray{T,N}).
+    # Instead, the KernelAbstractions extension defines the concrete CuArray dispatch.
     Base.convert(::Type{T}, VA::AbstractVectorOfArray) where {T <: GPUArraysCore.AnyGPUArray} = T(stack(VA.u))
-    # Constructor: CuArray(va) etc. Must disambiguate with CuArray(::AbstractArray{T,N})
-    # from CUDA.jl. AbstractVectorOfArray{T,N} is more specific than AbstractArray{T,N}
-    # on arg2, matching {T,N} ensures equal specificity to CUDA's method.
-    function (::Type{GA})(VA::AbstractVectorOfArray{T, N}) where {T, N, GA <: GPUArraysCore.AbstractGPUArray}
-        return GA(stack(VA.u))
-    end
 
     export VectorOfArray, VA, DiffEqArray, AbstractVectorOfArray, AbstractDiffEqArray,
         AllObserved, vecarr_to_vectors, tuples