AvroTraversal

Structural leftover: the original payload plus the located element-span plan (None on a whole-walk failure, in which case from returns the input).

.at(i) sugar — extend the suffix by an array index.

.field(_.x) sugar — extend the suffix by a named field.

.fieldNamed[B]("schema_name") — drill by EXPLICIT schema field name (issue #35 escape hatch), the traversal counterpart of AvroPrism.fieldNamed.

.fields(_.a, _.b, ...) — focus a NamedTuple per element.

Re-encode each focus and splice all spans back in one pass (re-framing the array region when the original framing was byte-sized); any refusal returns the input bytes.

The IndexedRecord-carried counterpart of this traversal — the Ior-bearing diagnostic surface (modify / getAll / place / transfer + *Unsafe) over IndexedRecord | Array[Byte] | String input:

 codecPrism[Basket].items.each.name.record.modify(_.toUpperCase)(record)

Dynamic field sugar — basket.items.each.name lowers to .field(_.name) via the macro. An Avro field named like a real member of this class must be drilled with the explicit .field(_.x) form.

Locate every element's focused span and slice-decode the focuses that exist; whole-walk failure yields no foci (and a None plan, so from passes the input through).

.union[Branch] — narrow the per-element focus to one union alternative.

Fused Traversal.andThen(Lens) — SplitCombineLens / SimpleLens (macro-lens) inner.

Fused Traversal.andThen(Lens) — lifts the lens through the same tuple2multifocusPSVec bridge the Morph-routed generic extension uses, then composes on the shared carrier. See the andThen(inner: Traversal) overload for why the concrete return type matters.

Fused same-carrier Traversal.andThen(Traversal) — same composition as the generic Optic.andThen (the mfAssocPSVec kernel), re-homed under the concrete Traversal class via Traversal.composed. The generic member returns an anonymous Optic, so a composed chain's .modify / .foldMap resolve to the generic extensions — which re-instantiate the parameterized mfFunctor[PSVec] / mfFold[PSVec] givens per call (the measured 40 B/op of the class scaladoc) and share one megamorphic body. Returning Traversal keeps the fused inline members (and per-site monomorphic to / from dispatch) on every chain.

ANY outer ∘ read-only inner — the inner is honestly one-way (T = Unit: a Getter, AffineFold, or Fold), so only the two READ sides matter and the composite collapses to the read-only join of their strengths via compose.ReadCompose (Getter / PickFold / ForgetFold).

A trait member (not an extension in the companion) deliberately: once a receiver is statically one of the fused concrete classes, its andThen member overloads enter resolution and Scala 3 never falls back to extension methods when they all fail — the collapse must be in the member overload set to be reachable without an expected-type ascription.

Only the inner's T is pinned to Unit; its B stays free (IB) even though read-only inners always have B = Unit. That keeps this overload strictly LESS specific than the same-carrier andThen above (which accepts every argument this one does whenever B = Unit at the receiver), so a same-carrier read-only ∘ read-only call resolves unambiguously to the AssociativeFunctor path and this one fires exactly on the cross-seam cells the generic member cannot type.

Compose with another optic under the shared carrier F. Requires AssociativeFunctor[F]. Cross-carrier composition (Lens → Optional, Lens → Traversal, …) goes through the Morph-summoning overload of this same method.

True iff a focus satisfies p, via the streaming foldMap under the disjunction monoid — member twin of the generic Optic.exists.

Fused foldMap — the default folds the focus vector via the cached pSVecFoldable, skipping the per-call mfFold[PSVec] given instantiation the generic extension pays. Deliberately a plain overridable def, unlike modify: the constructors override it with STREAMING folds that never call to(s) at all — a fold has no use for the reassembly context to must pack, so materializing the focus vector is pure overhead on the read path. Traversal.pEach folds the container directly through Traverse[T], Traversal.selfChildren folds the children vector without the carrier wrapper, and Traversal.composed nests the two sides' folds so a depth-k chain streams with no arrays at any depth. The O(n) allocation win dwarfs the fixed per-call cost the old inline splice protected against.

First focus, if any, via the streaming foldMap under a first-Some monoid — the member twin of the generic Optic.headOption extension, here so concrete Traversals skip the focus vector build (the extension routes through to(s)).

Focus count via the streaming foldMap — member twin of the generic Optic.length.

Fused modify — same logic as the generic extension, with the cached pSVecFunctor in place of the per-call mfFunctor[PSVec] given instantiation (−40 B/op with replace / foldMap's sibling savings; see the class scaladoc). inline so each call site splices its own copy — per-site monomorphic to / from dispatch.

Fused replace — constant-function modify.