Split any/all optimizations into separate subpackage

RecursiveArrayToolsShorthandConstructors now only has the VA[...] and
AP[...] constructor syntax. The any/all partition-level optimizations
are in their own RecursiveArrayToolsArrayPartitionOptimizations subpackage
since they are unrelated to shorthand constructors.

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

Author: ChrisRackauckas

lib/RecursiveArrayToolsArrayPartitionOptimizations/Project.toml

@@ -0,0 +1,10 @@
+name = "RecursiveArrayToolsArrayPartitionOptimizations"
+uuid = "ef3824f8-e6de-4318-b303-9eebc901ed99"
+version = "1.0.0"
+
+[deps]
+RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
+
+[compat]
+RecursiveArrayTools = "3.48"
+julia = "1.10"

lib/RecursiveArrayToolsArrayPartitionOptimizations/src/RecursiveArrayToolsArrayPartitionOptimizations.jl

@@ -0,0 +1,25 @@
+"""
+    RecursiveArrayToolsArrayPartitionOptimizations
+
+Optimized `any`/`all` for `ArrayPartition` that short-circuit at the
+partition level instead of element-by-element. Separated into its own
+subpackage because the `any(f::Function, ::ArrayPartition)` method
+invalidates ~780 downstream compiled specializations of
+`any(f::Function, ::AbstractArray)`.
+
+```julia
+using RecursiveArrayToolsArrayPartitionOptimizations
+```
+"""
+module RecursiveArrayToolsArrayPartitionOptimizations
+
+using RecursiveArrayTools: ArrayPartition
+
+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)
+
+end

lib/RecursiveArrayToolsShorthandConstructors/src/RecursiveArrayToolsShorthandConstructors.jl

@@ -1,36 +1,19 @@
 """
     RecursiveArrayToolsShorthandConstructors
 
-Opt-in subpackage providing shorthand syntax and optimized methods that cause
-method table invalidations. These are separated from RecursiveArrayTools to
-avoid invalidating compiled code for users who don't need them.
+Shorthand `VA[a, b, c]` and `AP[a, b, c]` constructor syntax. Separated
+into its own subpackage because `getindex(::Type{VA}, xs...)` invalidates
+`getindex(::Type{T}, vals...)` from Base.
 
 ```julia
 using RecursiveArrayToolsShorthandConstructors
 ```
-
-This enables:
-- `VA[a, b, c]` shorthand for `VectorOfArray([a, b, c])`
-- `AP[a, b, c]` shorthand for `ArrayPartition(a, b, c)`
-- Optimized `any`/`all` for `ArrayPartition` (partition-level short-circuiting)
 """
 module RecursiveArrayToolsShorthandConstructors
 
 using RecursiveArrayTools: VA, VectorOfArray, AP, ArrayPartition
 
-# VA[...] shorthand
 Base.getindex(::Type{VA}, xs...) = VectorOfArray(collect(xs))
-
-# AP[...] shorthand
 Base.getindex(::Type{AP}, xs...) = ArrayPartition(xs...)
 
-# Optimized any/all for ArrayPartition — applies f partition-by-partition
-# for faster short-circuiting instead of element-by-element.
-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)
-
-end # module
+end