Move VA/AP constructors and any/all optimizations to subpackage

Create lib/RecursiveArrayToolsShorthandConstructors as a separate
subpackage for methods that cause invalidations:

- VA[...] and AP[...] shorthand constructors (getindex on Type)
- Optimized any/all for ArrayPartition (partition-level short-circuit)

Users who want these opt in with:
  using RecursiveArrayToolsShorthandConstructors

Invalidation trees after `using RecursiveArrayTools`: 3 → 1
(only NamedArrayPartition.setindex! remains, pre-existing)

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

Author: ChrisRackauckas

Project.toml

@@ -1,7 +1,7 @@
 name = "RecursiveArrayTools"
 uuid = "731186ca-8d62-57ce-b412-fbd966d074cd"
-authors = ["Chris Rackauckas <accounts@chrisrackauckas.com>"]
 version = "3.48.0"
+authors = ["Chris Rackauckas <accounts@chrisrackauckas.com>"]
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

lib/RecursiveArrayToolsShorthandConstructors/Project.toml

@@ -0,0 +1,10 @@
+name = "RecursiveArrayToolsShorthandConstructors"
+uuid = "39fb7555-b4ad-4efd-8abe-30331df017d3"
+version = "1.0.0"
+
+[deps]
+RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
+
+[compat]
+RecursiveArrayTools = "3.48"
+julia = "1.10"

lib/RecursiveArrayToolsShorthandConstructors/src/RecursiveArrayToolsShorthandConstructors.jl

@@ -0,0 +1,36 @@
+"""
+    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.
+
+```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

src/array_partition.jl

@@ -223,12 +223,10 @@ end
     end
 end
 Base.filter(f, A::ArrayPartition) = ArrayPartition(map(x -> filter(f, x), A.x))
-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)
+# Optimized any/all for ArrayPartition (partition-level short-circuiting) moved to
+# RecursiveArrayTools.ShorthandConstructors to avoid invalidations (779 children).
+# The AbstractArray default any/all works correctly, just without partition-level optimization.
+# `using RecursiveArrayTools.ShorthandConstructors` to enable the optimized versions.
 
 for type in [AbstractArray, PermutedDimsArray]
     @eval function Base.copyto!(dest::$(type), A::ArrayPartition)
@@ -746,4 +744,5 @@ ODEProblem(func, AP[ [1.,2.,3.], [1. 2.;3. 4.] ], (0, 1)) |> solve
 
 """
 struct AP end
-Base.getindex(::Type{AP}, xs...) = ArrayPartition(xs...)
+# AP[...] shorthand moved to RecursiveArrayTools.ShorthandConstructors to avoid invalidations.
+# `using RecursiveArrayTools.ShorthandConstructors` to enable.

src/vector_of_array.jl

@@ -1315,4 +1315,5 @@ nested = VA[
 
 """
 struct VA end
-Base.getindex(::Type{VA}, xs...) = VectorOfArray(collect(xs))
+# VA[...] shorthand moved to RecursiveArrayTools.ShorthandConstructors to avoid invalidations.
+# `using RecursiveArrayTools.ShorthandConstructors` to enable.

test/basic_indexing.jl

@@ -1,4 +1,5 @@
 using RecursiveArrayTools, Test
+using RecursiveArrayToolsShorthandConstructors
 
 # Example Problem
 recs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

test/interface_tests.jl

@@ -1,4 +1,5 @@
 using RecursiveArrayTools, StaticArrays, Test
+using RecursiveArrayToolsShorthandConstructors
 using FastBroadcast
 using SymbolicIndexingInterface: SymbolCache
 

test/linalg.jl

@@ -1,4 +1,5 @@
 using RecursiveArrayTools, Test, Random
+using RecursiveArrayToolsShorthandConstructors
 using LinearAlgebra, ArrayInterface
 
 n, m = 5, 6

test/partitions_test.jl

@@ -1,4 +1,5 @@
 using RecursiveArrayTools, Test, Statistics, ArrayInterface, Adapt
+using RecursiveArrayToolsShorthandConstructors
 
 @test length(ArrayPartition()) == 0
 @test isempty(ArrayPartition())

test/runtests.jl

@@ -1,4 +1,7 @@
 using Pkg
+# Install the ShorthandConstructors subpackage for tests that need VA[...]/AP[...] syntax
+Pkg.develop(PackageSpec(
+    path = joinpath(dirname(@__DIR__), "lib", "RecursiveArrayToolsShorthandConstructors")))
 using RecursiveArrayTools
 using Test
 using SafeTestsets