Revert 1.13 any/all inlining — keep subpackage split, add comment

The 1.13 inlining of optimized any/all should be a separate PR.
Keep the clean split: RecursiveArrayToolsArrayPartitionAnyAll provides
the optimized methods, Base's AbstractArray fallback is used without it.

Tests verify dispatch goes to Base without extension, and the Subpackages
test group verifies loading the extension overrides correctly.

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

@@ -741,56 +741,9 @@ ODEProblem(func, AP[ [1.,2.,3.], [1. 2.;3. 4.] ], (0, 1)) |> solve
 """
 struct AP end
 
-# any/all on ArrayPartition: partition-level iteration avoids scalar GPU indexing
-# and is ~1.5-1.8x faster than element-by-element AbstractArray fallback.
-#
-# On Julia ≥ 1.13, Base no longer restricts any/all to f::Function, so defining
-# any(f, ::ArrayPartition) causes minimal invalidation. On older Julia, the
-# f::Function methods caused ~780 invalidations, so the optimized methods were
-# separated into RecursiveArrayToolsArrayPartitionAnyAll.
-#
-# We now define them inline with a GPU check: if sub-arrays are GPU arrays and
-# we're on old Julia without the extension, give a helpful error.
-@static if VERSION >= v"1.13.0-DEV.0"
-    # Julia 1.13+: safe to define directly, minimal invalidation
-    Base.any(f, A::ArrayPartition) = any((any(f, x) for x in A.x))
-    Base.any(f::Function, A::ArrayPartition) = any((any(f, x) for x in A.x))
-    Base.any(A::ArrayPartition) = any(identity, A)
-    Base.all(f, A::ArrayPartition) = all((all(f, x) for x in A.x))
-    Base.all(f::Function, A::ArrayPartition) = all((all(f, x) for x in A.x))
-    Base.all(A::ArrayPartition) = all(identity, A)
-else
-    # Julia < 1.13: only define GPU-check methods that error for GPU arrays
-    # and fall through to AbstractArray for CPU. The optimized partition-level
-    # methods are in RecursiveArrayToolsArrayPartitionAnyAll to avoid invalidations.
-    const _ANYALL_GPU_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_GPU_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
-end
+# Optimized partition-level any/all for ArrayPartition lives in
+# RecursiveArrayToolsArrayPartitionAnyAll to avoid ~780 invalidations.
+# Without the extension, any/all uses the AbstractArray element-by-element
+# fallback, which triggers scalar indexing errors on GPU arrays.
+# Load the subpackage to fix:
+#     using RecursiveArrayToolsArrayPartitionAnyAll

test/partitions_test.jl

@@ -178,21 +178,13 @@ recursivecopy!(dest_ap, src_ap)
 @inferred mapreduce(string, *, x)
 @test mapreduce(i -> string(i) * "q", *, x) == "1q2q3.0q4.0q"
 
-# any/all — on Julia ≥ 1.13, optimized partition-level methods are defined inline.
-# On older Julia, they require `using RecursiveArrayToolsArrayPartitionAnyAll`.
-@static if VERSION >= v"1.13.0-DEV.0"
-    # Optimized methods are always active on 1.13+
-    @test which(any, Tuple{Function, ArrayPartition}).module === RecursiveArrayTools
-    @test which(all, Tuple{Function, ArrayPartition}).module === RecursiveArrayTools
-else
-    # On older Julia, optimized methods require the extension
-    @test_broken occursin("ArrayPartitionAnyAll",
-        string(which(any, Tuple{Function, ArrayPartition}).module))
-    @test_broken occursin("ArrayPartitionAnyAll",
-        string(which(all, Tuple{Function, ArrayPartition}).module))
-end
+# any/all — optimized partition-level iteration requires RecursiveArrayToolsArrayPartitionAnyAll
+# to avoid ~780 invalidations. Without the extension, Base's AbstractArray fallback is used.
+# On GPU arrays, the fallback triggers scalar indexing errors — load the subpackage to fix.
+@test which(any, Tuple{Function, ArrayPartition}).module === Base
+@test which(all, Tuple{Function, ArrayPartition}).module === Base
 
-# Correctness tests
+# Correctness tests (work via AbstractArray fallback 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]])