linq_fold Phase 2C: take/skip splice + chained-select := clone

[borisbat]

Summary

Phase 2C of the _fold splice-mode buildout. Two rings + one small lint-driven gensym tweak.

Ring 3 — take(N) / skip(N) splice in all four lanes (eac77b8dd)

_fold now recognizes [where_*][select*][skip?][take?] |> terminator and emits per-element work wrapped with bounded-loop counters. Skip/take guards splice into the per-match block (after the optional where filter, before lane-specific work). Counters live alongside the lane's accumulator in the outer invoke.

• Planner state machine on (seenSelect, seenSkip, seenTake) enforces canonical chain order; reversed forms (where-after-select, etc.) fall through to plain linq.
• take/skip as trailing operator (no explicit to_array) routes to ARRAY lane with implicit to_array.
• Range-form take(start..end) falls through (different semantics — slice operator, future PR).
• Buffer-required marker arms for order_by/order_descending, distinct/distinct_by, reverse, group_by/group_by_lazy, zip, join/left_join/group_join — each gets a named recognition arm with a // TODO Phase 2X: <FutureMode> comment so future buffer-mode emission grafts in without re-walking the chain-recognition logic.
• Reserve hint refinement: when take(N) is present, array-lane reserve tightens from length(src) to min(N, length(src)) (inline ?: — no math::min dep at call site).
• Take-increment placement: BEFORE lane work, so early-exit terminators with return X don't trigger LINT001 unreachable.

Benchmarks (100K rows, INTERP):

Benchmark	Shape	m3f_old	m3f (Phase 2C)
take_count	take(N).to_array	0	0 (parity; structural splice win)
skip_take	skip(K).take(N).to_array	23	0
take_sum_aggregate (new)	select.take(N).sum	14	0
take_count_filtered (new)	where.take(N).count	11	0

Sub-ns/op reflects bounded-loop nature: actual loop runs ≤ K+N (≤ 1010 here vs 100K source).

qmatch gensym tweak (10e6cdca1)

Switch daslib/ast_match.das::next_var from qm_{n} to qm`{n}. Backtick is the established compiler-generated-name marker in daslib (linq_fold gensyms etc.), and daslib/lint.das:152 already skips backtick-bearing names from LINT004. Eliminates collision risk with any user identifier (qm_5 is a valid user identifier; qm`5 is not).

Ring 4 — chained-select clone via := (088d80ed0)

Drops the prevWorkhorse=false → return null Phase 2B placeholder guard at the chained-select arm. Correctness observation: := is safe on every type (byte copy on workhorse, deep-clone on non-workhorse). Single emission shape var $i(bind) := $e(projection) covers both cases. Chained selects of any type now splice through one path.

Concretely: each(arr)._select(ComplexType(a = [_*2]))._select(_.a[0]).sum() previously fell through to plain linq; now splices to a single fused for-loop.

Workhorse-branch audit — after Ring 4, two workhorse branches remain in linq_fold.das, both intentional:

1. fold_select_where static_if (typeinfo is_workhorse(...)) — _old_fold's frozen baseline path via g_foldSeq. Changing it would invalidate the m3f_old benchmark column.
2. min_max_compare workhorse < / > vs _::less — perf-critical (~2× per-element on int columns; PR linq_fold Phase 2B: aggregates + early-exit terminators (+ ICE 50609 defuse) #2696 numbers).

Planned: fail-loudly contract

Documented in benchmarks/sql/LINQ.md as the next planned PR. Current contract — _fold silently falls through to plain linq when it can't splice — is temporary. Planned switch: macro_error("_fold: cannot splice — <reason>") on any unsupported shape, mirroring sqlite_linq's "splice or error" contract. Buffer-required marker arms are pre-wired for this.

Test plan

• tests/linq/test_linq_fold.das — 167 tests pass (interpreter; +4 new test funcs covering counter/accumulator/early-exit/array lane take/skip + chained non-workhorse selects).
• tests/linq/test_linq_fold_ast.das — 71 tests pass (interpreter; +5 splice-shape assertions including order_by/distinct fall-through markers).
• Full tests/linq/ AOT suite — 734/734 pass with bin/test_aot -use-aot dastest/dastest.das -- --use-aot --test tests/linq.
• tests/ast_match/* regression — 69 tests pass (qmatch gensym tweak).
• mcp__daslang__format_file + mcp__daslang__lint clean on all 8 changed files.
• Dupe-detect run on changed .das (corpus: daslib + tests/linq) — only finding is a noise-level token-shape match between is_buffer_required_op and macro_boost::is_mutation_op2 (both are string → bool membership checks; different domains, no shared abstraction worth extracting).

Plan file: ~/.claude/plans/foamy-leaping-karp.md. Builds on PR #2696.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Phase 2C extends _fold's splice planner to recognize [where_*][select*][skip?][take?] |> terminator chains across all four lanes (counter / array / accumulator / early-exit), emitting bounded-loop counters spliced into the per-match block. Adds marker arms for buffer-required ops (order_by, distinct, reverse, group_by, zip, joins) that deliberately fall through with future-mode TODOs. Also drops the Phase 2B workhorse-only restriction on chained _select by using := (clone) for all intermediate binds — enabling chained non-workhorse projections to splice. Includes a small qmatch gensym tweak (_qm_{n} → qm`{n}) using the backtick compiler-generated marker, plus minor reserve() hints in chunk_impl/zip_impl.

Changes:

• Splice take/skip in 4 lanes via new helpers append_skip_take_prelude + wrap_with_skip_take; planner state machine on (seenSelect, seenSkip, seenTake) enforces canonical chain order.
• Switch chained _select intermediate bind from var = ... to var := ... (clone), removing the workhorse-only Phase 2B guard; add is_buffer_required_op marker arm.
• qmatch gensym uses backtick marker; some var → let for read-only locals.

Reviewed changes

Copilot reviewed 8 out of 8 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
daslib/linq_fold.das	Core: take/skip splice across lanes, chained-select := clone, buffer-required marker arm.
daslib/ast_match.das	qmatch gensym rename to backtick form; var→let for read-only helpers.
daslib/linq.das	Minor pre-reserve hints in chunk_impl and zip_impl.
tests/linq/test_linq_fold.das	+4 test funcs for take/skip lanes + chained non-workhorse select; widespread nolint:LINT003 annotations on existing var decls.
tests/linq/test_linq_fold_ast.das	+5 AST shape assertions (take splices break/continue; order_by/distinct fall through).
benchmarks/sql/take_sum_aggregate.das	New 100K benchmark for accumulator-lane take splice.
benchmarks/sql/take_count_filtered.das	New 100K benchmark for counter-lane take + where splice.
benchmarks/sql/LINQ.md	Phase 2C status + delta tables + planned fail-loudly contract.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 8 out of 8 changed files in this pull request and generated no new comments.