Add GPU error hint for any/all on ArrayPartition, test subpackage loading

Without RecursiveArrayToolsArrayPartitionAnyAll, any/all on ArrayPartition
with GPU sub-arrays would trigger scalar indexing errors. The base package
now defines any/all methods for ArrayPartition that:
- Check for GPU sub-arrays and throw a helpful error directing users to
  load RecursiveArrayToolsArrayPartitionAnyAll
- Fall through to AbstractArray element-by-element iteration for CPU arrays

Also adds a Subpackages test group that verifies loading
RecursiveArrayToolsArrayPartitionAnyAll correctly overrides the methods
with optimized partition-level iteration.

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

Author: ChrisRackauckas

src/array_partition.jl

@@ -740,3 +740,38 @@ ODEProblem(func, AP[ [1.,2.,3.], [1. 2.;3. 4.] ], (0, 1)) |> solve
 
 """
 struct AP end
+
+# any/all: provide methods that work partition-by-partition to avoid scalar indexing on GPUs.
+# Without RecursiveArrayToolsArrayPartitionAnyAll, the AbstractArray fallback iterates
+# element-by-element, which triggers scalar GPU indexing errors. These methods check for
+# GPU sub-arrays and give a helpful error, or fall through to the partition-level implementation.
+const _ANYALL_HINT = """
+    `any`/`all` on `ArrayPartition` with GPU arrays requires loading the subpackage:
+        using RecursiveArrayToolsArrayPartitionAnyAll
+    This provides optimized partition-level `any`/`all` that avoids scalar GPU indexing.
+    """
+
+function _check_gpu_anyall(A::ArrayPartition)
+    for x in A.x
+        if x isa GPUArraysCore.AnyGPUArray
+            error(_ANYALL_HINT)
+        end
+    end
+end
+
+function Base.any(f::Function, A::ArrayPartition)
+    _check_gpu_anyall(A)
+    return Base.invoke(any, Tuple{Function, AbstractArray}, f, A)
+end
+function Base.all(f::Function, A::ArrayPartition)
+    _check_gpu_anyall(A)
+    return Base.invoke(all, Tuple{Function, AbstractArray}, f, A)
+end
+function Base.any(f, A::ArrayPartition)
+    _check_gpu_anyall(A)
+    return Base.invoke(any, Tuple{Any, AbstractArray}, f, A)
+end
+function Base.all(f, A::ArrayPartition)
+    _check_gpu_anyall(A)
+    return Base.invoke(all, Tuple{Any, AbstractArray}, f, A)
+end

test/partitions_test.jl

@@ -178,14 +178,16 @@ recursivecopy!(dest_ap, src_ap)
 @inferred mapreduce(string, *, x)
 @test mapreduce(i -> string(i) * "q", *, x) == "1q2q3.0q4.0q"
 
-# any/all — optimized partition-level iteration requires RecursiveArrayToolsArrayPartitionAnyAll.
-# Without the extension, these use the AbstractArray element-by-element fallback.
-# `using RecursiveArrayToolsArrayPartitionAnyAll` enables ~1.5-1.8x faster partition-level
-# short-circuiting. These @test_broken verify the optimized methods are NOT active.
-@test_broken which(any, Tuple{Function, ArrayPartition}).module !== Base
-@test_broken which(all, Tuple{Function, ArrayPartition}).module !== Base
-
-# Correctness tests still pass via AbstractArray fallback
+# any/all — the base package defines GPU-aware methods that error for GPU sub-arrays
+# and fall through to AbstractArray iteration for CPU arrays. The optimized partition-level
+# iteration (1.5-1.8x faster) requires `using RecursiveArrayToolsArrayPartitionAnyAll`.
+# These @test_broken verify the optimized extension is NOT loaded.
+@test_broken occursin("ArrayPartitionAnyAll",
+    string(which(any, Tuple{Function, ArrayPartition}).module))
+@test_broken occursin("ArrayPartitionAnyAll",
+    string(which(all, Tuple{Function, ArrayPartition}).module))
+
+# Correctness tests pass via the base package methods (element-by-element on CPU)
 @test !any(isnan, AP[[1, 2], [3.0, 4.0]])
 @test !any(isnan, AP[[3.0, 4.0]])
 @test  any(isnan, AP[[NaN], [3.0, 4.0]])

test/runtests.jl

@@ -45,6 +45,25 @@ end
         @time @safetestset "SymbolicIndexingInterface API test" include("symbolic_indexing_interface_test.jl")
     end
 
+    if GROUP == "Subpackages" || GROUP == "All"
+        # Test that loading RecursiveArrayToolsArrayPartitionAnyAll overrides any/all
+        Pkg.develop(PackageSpec(
+            path = joinpath(dirname(@__DIR__), "lib", "RecursiveArrayToolsArrayPartitionAnyAll")))
+        @time @safetestset "ArrayPartition AnyAll Subpackage" begin
+            using RecursiveArrayTools, RecursiveArrayToolsArrayPartitionAnyAll, Test
+            # Verify optimized methods are active
+            m_any = which(any, Tuple{Function, ArrayPartition})
+            m_all = which(all, Tuple{Function, ArrayPartition})
+            @test occursin("ArrayPartitionAnyAll", string(m_any.module))
+            @test occursin("ArrayPartitionAnyAll", string(m_all.module))
+            # Verify correctness
+            @test  any(isnan, ArrayPartition([NaN], [1.0]))
+            @test !any(isnan, ArrayPartition([1.0], [2.0]))
+            @test  all(isnan, ArrayPartition([NaN], [NaN]))
+            @test !all(isnan, ArrayPartition([NaN], [1.0]))
+        end
+    end
+
     if GROUP == "Downstream"
         activate_downstream_env()
         @time @safetestset "ODE Solve Tests" include("downstream/odesolve.jl")