Skip to main content

miniextendr_macros/
dataframe_derive.rs

1//! Derive macros for bidirectional row ↔ dataframe conversions.
2//!
3//! Supports both structs (direct field mapping) and enums (field-name union
4//! across variants with `Option<T>` fill for missing fields).
5
6use proc_macro2::{Span, TokenStream};
7use quote::{format_ident, quote, quote_spanned};
8use syn::{Data, DeriveInput, Fields};
9
10// region: Attribute parsing
11
12/// Parsed container-level `#[dataframe(...)]` attributes.
13pub(super) struct DataFrameAttrs {
14    /// Custom companion type name (default: `{TypeName}DataFrame`).
15    pub(super) name: Option<syn::Ident>,
16    /// Enum alignment mode — implicit for enums, accepted but not required.
17    pub(super) align: bool,
18    /// Tag column name for variant discriminator (also supported on structs).
19    pub(super) tag: Option<String>,
20    /// Conflict resolution mode for type collisions across enum variants.
21    /// Currently only "string" is supported: convert conflicting fields via `ToString`.
22    pub(super) conflicts: Option<String>,
23}
24
25/// Parse container-level `#[dataframe(...)]` attributes from the derive input.
26///
27/// Supported keys:
28/// - `name = "CustomName"` -- custom companion type name (default: `{TypeName}DataFrame`)
29/// - `align` -- enum alignment mode (field-name union across variants)
30/// - `tag = "col_name"` -- add a variant discriminator column (works on both structs and enums)
31/// - `conflicts = "string"` -- coerce type-conflicting columns to `String` via `ToString`
32///
33/// Returns `Err` for unknown keys or non-string-literal values.
34fn parse_dataframe_attrs(input: &DeriveInput) -> syn::Result<DataFrameAttrs> {
35    let mut attrs = DataFrameAttrs {
36        name: None,
37        align: false,
38        tag: None,
39        conflicts: None,
40    };
41
42    for attr in &input.attrs {
43        if !attr.path().is_ident("dataframe") {
44            continue;
45        }
46
47        let nested = attr.parse_args_with(
48            syn::punctuated::Punctuated::<syn::Meta, ::syn::token::Commasyn::Token![,]>::parse_terminated,
49        )?;
50
51        for meta in &nested {
52            match meta {
53                syn::Meta::NameValue(nv) if nv.path.is_ident("name") => {
54                    if let syn::Expr::Lit(syn::ExprLit {
55                        lit: syn::Lit::Str(lit_str),
56                        ..
57                    }) = &nv.value
58                    {
59                        attrs.name =
60                            Some(match ::quote::__private::IdentFragmentAdapter(&lit_str.value()) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(lit_str.span())),
}format_ident!("{}", lit_str.value(), span = lit_str.span()));
61                    } else {
62                        return Err(syn::Error::new_spanned(
63                            &nv.value,
64                            "expected string literal for `name`",
65                        ));
66                    }
67                }
68                syn::Meta::NameValue(nv) if nv.path.is_ident("tag") => {
69                    if let syn::Expr::Lit(syn::ExprLit {
70                        lit: syn::Lit::Str(lit_str),
71                        ..
72                    }) = &nv.value
73                    {
74                        attrs.tag = Some(lit_str.value());
75                    } else {
76                        return Err(syn::Error::new_spanned(
77                            &nv.value,
78                            "expected string literal for `tag`",
79                        ));
80                    }
81                }
82                syn::Meta::NameValue(nv) if nv.path.is_ident("conflicts") => {
83                    if let syn::Expr::Lit(syn::ExprLit {
84                        lit: syn::Lit::Str(lit_str),
85                        ..
86                    }) = &nv.value
87                    {
88                        let value = lit_str.value();
89                        if value != "string" {
90                            return Err(syn::Error::new_spanned(
91                                lit_str,
92                                "unknown conflict resolution mode; only `\"string\"` is supported",
93                            ));
94                        }
95                        attrs.conflicts = Some(value);
96                    } else {
97                        return Err(syn::Error::new_spanned(
98                            &nv.value,
99                            "expected string literal for `conflicts`",
100                        ));
101                    }
102                }
103                syn::Meta::Path(path) if path.is_ident("align") => {
104                    attrs.align = true;
105                }
106                other => {
107                    return Err(syn::Error::new_spanned(
108                        other,
109                        "unknown dataframe attribute; expected `name`, `align`, `tag`, or `conflicts`",
110                    ));
111                }
112            }
113        }
114    }
115
116    Ok(attrs)
117}
118// endregion
119
120// region: Field-level attribute parsing
121
122/// Parsed field-level `#[dataframe(...)]` attributes.
123///
124/// These attributes control how individual struct/enum fields map to DataFrame columns.
125/// Mutually exclusive combinations (`as_list` + `expand`, `as_list` + `width`,
126/// `as_factor` + `as_list`, `as_factor` + `expand`, `as_factor` + `width`) are
127/// rejected during parsing.
128#[derive(#[automatically_derived]impl ::core::default::Default for FieldAttrs {
    #[inline]
    fn default() -> Self {
        FieldAttrs {
            skip: ::core::default::Default::default(),
            rename: ::core::default::Default::default(),
            as_list: ::core::default::Default::default(),
            as_factor: ::core::default::Default::default(),
            expand: ::core::default::Default::default(),
            width: ::core::default::Default::default(),
        }
    }
}Default)]
129pub(super) struct FieldAttrs {
130    /// `#[dataframe(skip)]` -- omit this field from the DataFrame entirely.
131    pub(super) skip: bool,
132    /// `#[dataframe(rename = "col")]` -- use a custom column name instead of the field name.
133    pub(super) rename: Option<String>,
134    /// `#[dataframe(as_list)]` -- keep a collection field as a single R list column
135    /// (suppresses automatic expansion into suffixed columns).
136    pub(super) as_list: bool,
137    /// `#[dataframe(as_factor)]` -- treat a unit-only inner enum field as an R factor column.
138    /// Only valid on bare-ident enum types (no generic parameters). The inner enum must be
139    /// unit-only (`#[derive(DataFrameRow)]` emits `IntoR` and `IntoR for Vec<Option<Self>>`).
140    pub(super) as_factor: bool,
141    /// `#[dataframe(expand)]` or `#[dataframe(unnest)]` -- explicitly expand a
142    /// collection field into multiple suffixed columns.
143    expand: bool,
144    /// `#[dataframe(width = N)]` -- pin the expansion width for `Vec<T>`, `Box<[T]>`,
145    /// or `&[T]` fields. Rows shorter than `N` get `None` for missing positions.
146    pub(super) width: Option<usize>,
147}
148
149/// Parse field-level `#[dataframe(...)]` attributes from a `syn::Field`.
150///
151/// Recognizes: `skip`, `rename`, `as_list`, `as_factor`, `expand` (alias `unnest`), and `width`.
152/// Validates mutual exclusivity of conflicting options (`as_list` vs `expand`/`width`,
153/// `as_factor` vs `as_list`/`expand`/`width`).
154/// Returns `Err` for unknown keys, invalid width values, or conflicting options.
155pub(super) fn parse_field_attrs(field: &syn::Field) -> syn::Result<FieldAttrs> {
156    let mut attrs = FieldAttrs::default();
157
158    for attr in &field.attrs {
159        if !attr.path().is_ident("dataframe") {
160            continue;
161        }
162
163        attr.parse_nested_meta(|meta| {
164            if meta.path.is_ident("skip") {
165                attrs.skip = true;
166                Ok(())
167            } else if meta.path.is_ident("rename") {
168                let value = meta.value()?;
169                let lit: syn::LitStr = value.parse()?;
170                attrs.rename = Some(lit.value());
171                Ok(())
172            } else if meta.path.is_ident("as_list") {
173                attrs.as_list = true;
174                Ok(())
175            } else if meta.path.is_ident("as_factor") {
176                attrs.as_factor = true;
177                Ok(())
178            } else if meta.path.is_ident("expand") || meta.path.is_ident("unnest") {
179                attrs.expand = true;
180                Ok(())
181            } else if meta.path.is_ident("width") {
182                let value = meta.value()?;
183                let lit: syn::LitInt = value.parse()?;
184                let n: usize = lit.base10_parse()?;
185                if n == 0 {
186                    return Err(syn::Error::new(lit.span(), "`width` must be >= 1"));
187                }
188                attrs.width = Some(n);
189                Ok(())
190            } else {
191                Err(meta.error(
192                    "unknown field attribute; expected `skip`, `rename`, `as_list`, `as_factor`, `expand`, `unnest`, or `width`",
193                ))
194            }
195        })?;
196    }
197
198    let span = field.ident.as_ref().map_or(Span::call_site(), |i| i.span());
199
200    // Validation: conflicting options
201    if attrs.as_list && attrs.expand {
202        return Err(syn::Error::new(
203            span,
204            "`as_list` and `expand`/`unnest` are mutually exclusive",
205        ));
206    }
207    if attrs.as_list && attrs.width.is_some() {
208        return Err(syn::Error::new(
209            span,
210            "`as_list` and `width` are mutually exclusive",
211        ));
212    }
213    if attrs.as_factor && attrs.as_list {
214        return Err(syn::Error::new(
215            span,
216            "`as_factor` and `as_list` are mutually exclusive",
217        ));
218    }
219    if attrs.as_factor && attrs.expand {
220        return Err(syn::Error::new(
221            span,
222            "`as_factor` and `expand`/`unnest` are mutually exclusive",
223        ));
224    }
225    if attrs.as_factor && attrs.width.is_some() {
226        return Err(syn::Error::new(
227            span,
228            "`as_factor` and `width` are mutually exclusive",
229        ));
230    }
231
232    Ok(attrs)
233}
234// endregion
235
236// region: Type classification
237
238/// Classification of a field type for DataFrame column expansion.
239///
240/// Used to decide whether a field maps to a single column or should be
241/// expanded into multiple suffixed columns (e.g., `coords_1`, `coords_2`).
242pub(super) enum FieldTypeKind<'a> {
243    /// Single column (most types). No expansion.
244    Scalar,
245    /// `[T; N]` -- fixed-size array, expands to `N` columns at compile time.
246    /// Contains the element type and array length.
247    FixedArray(&'a syn::Type, usize),
248    /// `Vec<T>` -- variable length, needs `width` attribute or `expand` for expansion.
249    /// Contains the element type.
250    VariableVec(&'a syn::Type),
251    /// `Box<[T]>` -- owned slice, treated like `Vec<T>` for expansion purposes.
252    /// Contains the element type.
253    BoxedSlice(&'a syn::Type),
254    /// `&[T]` -- borrowed slice, treated like `Vec<T>` for expansion purposes.
255    /// Contains the element type.
256    BorrowedSlice(&'a syn::Type),
257    /// `HashMap<K, V>` or `BTreeMap<K, V>`. The two derive paths treat maps
258    /// differently:
259    /// - *enum path*: expands to two parallel list-columns `<field>_keys` /
260    ///   `<field>_values` (see `enum_expansion.rs`).
261    /// - *struct path*: resolves to a `Single` opaque list-of-named-lists
262    ///   column (`Vec<map>: IntoR`); reader-capable for `String` keys +
263    ///   reader-scalar values (#764, see `SingleFieldData::map_reader`).
264    ///
265    /// Key order follows the map's own iteration order: `BTreeMap` yields
266    /// sorted keys, `HashMap` yields non-deterministic order.
267    Map {
268        key_ty: &'a syn::Type,
269        val_ty: &'a syn::Type,
270    },
271    /// `Option<scalar>` (`Option<f64>`, `Option<String>`, …): one NA-able
272    /// column. The companion stores the full `Vec<Option<T>>`, whose `IntoR`
273    /// writes `None` as the typed `NA` and whose `TryFromSexp` reads `NA` back
274    /// as `None`; the inner type is never needed separately.
275    ///
276    /// Only the **struct** path accepts this shape. Enum variant fields are
277    /// already wrapped in `Option` (absent for other variants), so an
278    /// `Option<scalar>` field there would need `Vec<Option<Option<T>>>`, which
279    /// has no conversion; `enum_expansion.rs` rejects it with a pointer to the
280    /// bare scalar. Non-scalar `Option<…>` payloads (maps, structs, collections)
281    /// are still rejected in `classify_field_type` (#484).
282    OptionScalar,
283    /// A struct-typed field whose inner type implements `DataFrameRow`.
284    ///
285    /// Flattened into `<field>_<inner_col>` prefixed columns by default.
286    /// A compile-time assertion against `::miniextendr_api::markers::DataFrameRow`
287    /// is emitted so rustc gives a clear error when the inner type is missing the
288    /// derive.
289    ///
290    /// Suppressed by `#[dataframe(as_list)]` — with as_list the field becomes
291    /// a `Scalar` and uses the ordinary single-column codegen path.
292    Struct {
293        /// The full field type (used for the compile-time DataFrameRow assertion).
294        inner_ty: &'a syn::Type,
295    },
296}
297
298/// Classify a field type for DataFrame column expansion.
299///
300/// Inspects the type AST to detect:
301/// - `[T; N]` or `&[T; N]` -> `FixedArray`
302/// - `&[T]` -> `BorrowedSlice`
303/// - `Vec<T>` -> `VariableVec`
304/// - `Box<[T]>` -> `BoxedSlice`
305/// - `HashMap<K, V>` / `BTreeMap<K, V>` -> `Map`
306/// - `Option<scalar>`, or `Option` around a datetime crate path -> `OptionScalar`
307/// - A datetime crate path (`jiff::Timestamp`, `time::Date`, see
308///   [`DATETIME_PATHS`]) -> `Scalar`
309/// - Any non-scalar bare path type (single- or multi-segment, e.g. `Point` or
310///   `crate::geom::Point`) -> `Struct`
311/// - Everything else (known scalars, generic types with args, `::abs::Paths`) -> `Scalar`
312///
313/// Returns `Err` for shapes the macro cannot classify and that would silently
314/// become opaque list-columns: `Option<T>`, `Cow<T>`, `Rc<T>`, `Arc<T>`,
315/// `RefCell<T>`, `Cell<T>`, `Mutex<T>`, `RwLock<T>`.  Use
316/// `#[dataframe(as_list)]` to opt into list-column treatment explicitly.
317pub(super) fn classify_field_type(ty: &syn::Type) -> syn::Result<FieldTypeKind<'_>> {
318    // Check for [T; N]
319    if let syn::Type::Array(arr) = ty
320        && let syn::Expr::Lit(syn::ExprLit {
321            lit: syn::Lit::Int(lit_int),
322            ..
323        }) = &arr.len
324        && let Ok(n) = lit_int.base10_parse::<usize>()
325    {
326        return Ok(FieldTypeKind::FixedArray(&arr.elem, n));
327    }
328
329    // Check for &[T] and &[T; N]
330    if let syn::Type::Reference(ref_ty) = ty {
331        // &[T] → BorrowedSlice
332        if let syn::Type::Slice(slice) = &*ref_ty.elem {
333            return Ok(FieldTypeKind::BorrowedSlice(&slice.elem));
334        }
335        // &[T; N] → FixedArray (same as owned)
336        if let syn::Type::Array(arr) = &*ref_ty.elem
337            && let syn::Expr::Lit(syn::ExprLit {
338                lit: syn::Lit::Int(lit_int),
339                ..
340            }) = &arr.len
341            && let Ok(n) = lit_int.base10_parse::<usize>()
342        {
343            return Ok(FieldTypeKind::FixedArray(&arr.elem, n));
344        }
345    }
346
347    if let syn::Type::Path(type_path) = ty
348        && let Some(seg) = type_path.path.segments.last()
349        && let syn::PathArguments::AngleBracketed(args) = &seg.arguments
350    {
351        // Reject wrapper types that would silently fall through to Scalar /
352        // Struct and produce a confusing opaque list-column or a downstream
353        // DataFrameRow assertion error.  These are the common smart-pointer
354        // and interior-mutability types that wrap a meaningful inner type but
355        // that DataFrameRow does not know how to expand.
356        //
357        // The macro has no way to resolve through the wrapper without type-
358        // checking (which is unavailable in proc macros). The user must either
359        // unwrap to the inner type, or annotate with `#[dataframe(as_list)]`
360        // to opt into an explicit opaque list-column.
361        //
362        // IMPORTANT: The rejection fires on *path identity alone*, before we
363        // inspect generic args.  `Cow<'a, T>` has a lifetime as its first
364        // generic argument, not a type; inspecting `args.args.first()` as a
365        // `GenericArgument::Type` would silently skip `Cow`.  Checking ident
366        // before args makes the rejection robust to any generic shape.
367        const REJECTED_WRAPPERS: &[&str] = &[
368            "Option", "Cow", "Rc", "Arc", "RefCell", "Cell", "Mutex", "RwLock",
369        ];
370        let name = seg.ident.to_string();
371        // `Option<scalar>` is the NA contract (`None` ⇄ `NA`), not a wrapper to
372        // see through: `Vec<Option<T>>` has `IntoR` / `TryFromSexp` for every
373        // name in `OPTION_SCALAR_NAMES`, so it is a plain single column (#1437).
374        if name == "Option"
375            && let Some(syn::GenericArgument::Type(inner)) = args.args.first()
376        {
377            if is_known_scalar_ty(inner, &["u8"]) {
378                return Err(syn::Error::new_spanned(
379                    ty,
380                    "DataFrameRow cannot represent `Option<u8>` as a column: R raw vectors \
381                     have no NA value. Use `u8` for a non-missing raw column, or \
382                     `Option<u16>` / `Option<i32>` for a nullable integer column.",
383                ));
384            }
385            if is_option_scalar_inner(inner) || is_datetime_ty(inner) {
386                return Ok(FieldTypeKind::OptionScalar);
387            }
388        }
389        if REJECTED_WRAPPERS.contains(&name.as_str()) {
390            let hint = if name == "Option" {
391                "`Option<…>` is supported only around a scalar (`Option<f64>`, \
392                 `Option<String>`, …) or a datetime type spelled by its crate path \
393                 (`Option<jiff::Timestamp>`, `Option<time::Date>`, …), where it is the \
394                 NA-able column contract. "
395            } else {
396                ""
397            };
398            return Err(syn::Error::new_spanned(
399                ty,
400                ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("DataFrameRow does not support `{0}<…>` directly as a field type. {1}Use `#[dataframe(as_list)]` to opt into an explicit opaque list-column, or unwrap to the inner type (e.g. store the inner value directly, using a sentinel / empty collection for the absent case).",
                name, hint))
    })format!(
401                    "DataFrameRow does not support `{name}<…>` directly as a field type. {hint}\
402                     Use `#[dataframe(as_list)]` to opt into an explicit opaque list-column, \
403                     or unwrap to the inner type (e.g. store the inner value directly, using \
404                     a sentinel / empty collection for the absent case)."
405                ),
406            ));
407        }
408
409        // For the collection types below we need the first *type* argument.
410        // Skip any leading lifetime or const arguments (e.g. `Cow<'a, B>`
411        // has a lifetime first, but `Cow` is already rejected above so we
412        // only reach here for other angle-bracketed types).
413        let first_type_arg = args.args.iter().find_map(|arg| {
414            if let syn::GenericArgument::Type(t) = arg {
415                Some(t)
416            } else {
417                None
418            }
419        });
420
421        if let Some(inner) = first_type_arg {
422            // Check for Vec<T>
423            if seg.ident == "Vec" {
424                return Ok(FieldTypeKind::VariableVec(inner));
425            }
426
427            // Check for Box<[T]>
428            if seg.ident == "Box"
429                && let syn::Type::Slice(slice) = inner
430            {
431                return Ok(FieldTypeKind::BoxedSlice(&slice.elem));
432            }
433
434            // Check for HashMap<K, V> and BTreeMap<K, V>
435            if (seg.ident == "HashMap" || seg.ident == "BTreeMap")
436                && let Some(syn::GenericArgument::Type(val_ty)) = args.args.iter().nth(1)
437            {
438                return Ok(FieldTypeKind::Map {
439                    key_ty: inner,
440                    val_ty,
441                });
442            }
443        }
444    }
445
446    // Any remaining path type whose LAST segment is a bare ident (no generic args)
447    // that is NOT a known scalar is treated as a user-defined struct whose
448    // `DataFrameRow` derive should be called.  The compile-time assertion
449    // `_assert_inner_is_dataframe_row::<Inner>()` in the generated code surfaces a
450    // clear error if the inner type doesn't have the derive.
451    //
452    // Known scalars (i32, f64, String, bool, …) are kept as `Scalar` so that existing
453    // enum variants with primitive fields (e.g. `Click { id: i64, x: f64 }`) are not
454    // misclassified as struct fields.
455    //
456    // Multi-segment paths (e.g. `crate::geom::Point`, `geom::Point`) are now correctly
457    // classified here — the previous `segs.len() == 1` guard was overly restrictive.
458    // Paths with a leading `::` (absolute paths like `::std::ffi::CString`) still fall
459    // through to `Scalar`; use `#[dataframe(as_list)]` or an unqualified import if
460    // you need a custom treatment.
461    //
462    // RISK: a user type whose last path segment is named after a known-scalar
463    // (e.g. `mymod::String`) still correctly falls through to `Scalar` because of the
464    // KNOWN_SCALARS check. A type named `mymod::Option` / `mymod::Vec` would shadow
465    // the detection above — accepted per Rust naming convention (canonical names are
466    // rarely shadowed). `#[dataframe(as_list)]` is the documented escape hatch.
467    //
468    // A datetime type spelled by its crate path (`jiff::Timestamp`, `time::Date`)
469    // is one column, not a struct to flatten; see `DATETIME_PATHS` for the rule.
470    if is_datetime_ty(ty) {
471        return Ok(FieldTypeKind::Scalar);
472    }
473    if let syn::Type::Path(type_path) = ty {
474        let segs = &type_path.path.segments;
475        // No leading colon (rules out `::std::…` absolute paths) and no self-type.
476        if type_path.qself.is_none() && type_path.path.leading_colon.is_none() {
477            let seg = segs.last().unwrap();
478            if #[allow(non_exhaustive_omitted_patterns)] match seg.arguments {
    syn::PathArguments::None => true,
    _ => false,
}matches!(seg.arguments, syn::PathArguments::None) {
479                let name = seg.ident.to_string();
480                // Known scalar type names — keep as Scalar so they do not trigger the
481                // struct-flatten path and the DataFrameRow compile-time assertion.
482                const KNOWN_SCALARS: &[&str] = &[
483                    "bool", "char", "str", "f32", "f64", "i8", "i16", "i32", "i64", "i128",
484                    "isize", "u8", "u16", "u32", "u64", "u128", "usize", "String",
485                ];
486                if !KNOWN_SCALARS.contains(&name.as_str()) {
487                    return Ok(FieldTypeKind::Struct { inner_ty: ty });
488                }
489            }
490        }
491    }
492
493    Ok(FieldTypeKind::Scalar)
494}
495
496/// Scalar element types whose `Vec<T>` (and `Vec<Option<T>>`) round-trips through
497/// `TryFromSexp` — the supported field types for the parallel from-R reader
498/// (`try_from_dataframe_par`). This is intentionally narrower than
499/// `FieldTypeKind::Scalar`: set/opaque collection types (`HashSet<…>`,
500/// `BTreeSet<…>`) also classify as `Scalar` but do NOT implement `Vec<_>:
501/// TryFromSexp`, so they must be excluded from the reader path.
502///
503/// `pub(super)` so `enum_expansion.rs` (in the `dataframe_derive` module dir)
504/// can reuse the same allow-list without duplication.
505pub(super) const READER_SCALAR_NAMES: &[&str] = &[
506    "bool", "f32", "f64", "i8", "i16", "i32", "i64", "u8", "u16", "u32", "String",
507];
508
509/// Scalar types accepted inside `Option<…>` as a struct-path field (#1437):
510/// every `T` here has `IntoR for Vec<Option<T>>` (typed `NA` for `None`) in
511/// `miniextendr-api::into_r`. The reader side is gated separately by
512/// [`is_reader_scalar_ty`], so `Option<u64>` / `Option<usize>` fields are
513/// write-only, like their bare counterparts.
514pub(super) const OPTION_SCALAR_NAMES: &[&str] = &[
515    "bool", "f32", "f64", "i8", "i16", "i32", "i64", "u16", "u32", "u64", "isize", "usize",
516    "String",
517];
518
519/// Datetime types that `DataFrameRow` stores as one column (`T`) or one NA-able
520/// column (`Option<T>`): miniextendr-api has `IntoR` and `TryFromSexp` for
521/// `Vec<T>` and `Vec<Option<T>>` of each, under its `jiff` / `time` feature.
522///
523/// Unlike the scalar names, these are recognized by crate path only:
524/// `jiff::Timestamp`, `::jiff::Timestamp` or `miniextendr_api::jiff::Timestamp`,
525/// never a bare `Timestamp` or `Date`. A proc macro can't see imports, and a
526/// bare name may be the user's own struct, which flattens as a nested
527/// `DataFrameRow` as before. RISK: a local module named `jiff` or `time`
528/// holding a struct of one of these names reads as the crate's type; spell
529/// that path `self::time::Date` or `crate::time::Date` to flatten it.
530const DATETIME_PATHS: &[&[&str]] = &[
531    &["jiff", "Timestamp"],
532    &["jiff", "Zoned"],
533    &["jiff", "SignedDuration"],
534    &["jiff", "civil", "Date"],
535    &["time", "OffsetDateTime"],
536    &["time", "Date"],
537];
538
539/// The [`DATETIME_PATHS`] entry `tp` spells, with or without a leading `::`
540/// or the `miniextendr_api::` re-export of the crate.
541fn datetime_path(tp: &syn::TypePath) -> Option<&'static [&'static str]> {
542    if tp.qself.is_some()
543        || tp
544            .path
545            .segments
546            .iter()
547            .any(|seg| !#[allow(non_exhaustive_omitted_patterns)] match seg.arguments {
    syn::PathArguments::None => true,
    _ => false,
}matches!(seg.arguments, syn::PathArguments::None))
548    {
549        return None;
550    }
551    let idents: Vec<String> = tp
552        .path
553        .segments
554        .iter()
555        .map(|seg| seg.ident.to_string())
556        .collect();
557    let crate_path = match idents.split_first() {
558        Some((first, rest)) if first == "miniextendr_api" => rest,
559        _ => &idents[..],
560    };
561    DATETIME_PATHS.iter().copied().find(|path| {
562        path.iter()
563            .copied()
564            .eq(crate_path.iter().map(String::as_str))
565    })
566}
567
568/// True if `ty` is a datetime type spelled by its crate path ([`DATETIME_PATHS`]).
569pub(super) fn is_datetime_ty(ty: &syn::Type) -> bool {
570    #[allow(non_exhaustive_omitted_patterns)] match ty {
    syn::Type::Path(tp) if datetime_path(tp).is_some() => true,
    _ => false,
}matches!(ty, syn::Type::Path(tp) if datetime_path(tp).is_some())
571}
572
573/// The datetime type of a `T` or `Option<T>` field ([`DATETIME_PATHS`]).
574pub(super) fn datetime_column_ty(ty: &syn::Type) -> Option<&syn::Type> {
575    if is_datetime_ty(ty) {
576        Some(ty)
577    } else {
578        option_payload(ty).filter(|inner| is_datetime_ty(inner))
579    }
580}
581
582/// One compile-time check per datetime type in `tys`: without the matching
583/// miniextendr-api feature, the field reports the feature to enable
584/// (`markers::DataFrameDateTime`) instead of a bare missing `IntoR` impl.
585pub(super) fn datetime_feature_assertions<'a>(
586    tys: impl IntoIterator<Item = &'a syn::Type>,
587) -> Vec<TokenStream> {
588    tys.into_iter()
589        .map(|ty| {
590            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "const");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "_assert_datetime_column");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "T");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "markers");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameDateTime");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "_do_assert");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s,
                        "_assert_datetime_column");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&ty, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
591                const _: () = {
592                    fn _assert_datetime_column<T: ::miniextendr_api::markers::DataFrameDateTime>() {}
593                    fn _do_assert() {
594                        _assert_datetime_column::<#ty>();
595                    }
596                };
597            }
598        })
599        .collect()
600}
601
602/// Match the final scalar name, as field classification does. Absolute and
603/// relative paths have the same conversion support; associated types and
604/// generic payloads still need their own classification.
605fn is_known_scalar_ty(ty: &syn::Type, names: &[&str]) -> bool {
606    if let syn::Type::Path(tp) = ty
607        && tp.qself.is_none()
608        && let Some(seg) = tp.path.segments.last()
609        && #[allow(non_exhaustive_omitted_patterns)] match seg.arguments {
    syn::PathArguments::None => true,
    _ => false,
}matches!(seg.arguments, syn::PathArguments::None)
610    {
611        return names.contains(&seg.ident.to_string().as_str());
612    }
613    false
614}
615
616/// True if `ty` is `u8`, bare or qualified. R stores it in a raw vector, which
617/// has no NA, so a `u8` column cannot pad or omit cells (`Vec<Option<u8>>` has
618/// no `IntoR`).
619pub(super) fn is_raw_scalar_ty(ty: &syn::Type) -> bool {
620    is_known_scalar_ty(ty, &["u8"])
621}
622
623/// The payload of `Option<T>` (possibly qualified), if `ty` is one.
624pub(super) fn option_payload(ty: &syn::Type) -> Option<&syn::Type> {
625    if let syn::Type::Path(tp) = ty
626        && tp.qself.is_none()
627        && let Some(seg) = tp.path.segments.last()
628        && seg.ident == "Option"
629        && let syn::PathArguments::AngleBracketed(args) = &seg.arguments
630        && let Some(syn::GenericArgument::Type(inner)) = args.args.first()
631    {
632        return Some(inner);
633    }
634    None
635}
636
637/// A `u8` in a column whose cells can be NA. `why` names the source of the NA
638/// cells and `fix` the alternative, so the error points at the field instead of
639/// the missing `IntoR` impl inside the generated code (#2025).
640pub(super) fn raw_na_column_error(ty: &syn::Type, why: &str, fix: &str) -> syn::Error {
641    syn::Error::new_spanned(
642        ty,
643        ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("DataFrameRow cannot store `u8` here: {0}, and R raw vectors have no NA value. {1}",
                why, fix))
    })format!(
644            "DataFrameRow cannot store `u8` here: {why}, and R raw vectors have no NA \
645             value. {fix}"
646        ),
647    )
648}
649
650/// True if `ty` names a type from [`OPTION_SCALAR_NAMES`] (possibly qualified,
651/// without generic args), a valid payload for a single NA-able column.
652pub(super) fn is_option_scalar_inner(ty: &syn::Type) -> bool {
653    is_known_scalar_ty(ty, OPTION_SCALAR_NAMES)
654}
655
656/// True if `ty` names a known scalar, qualified or bare (no `Option` or generics).
657///
658/// These are the element types whose `Vec<Option<ty>>` round-trips through
659/// `TryFromSexp` — required for the *column-expansion* readers, which read each
660/// expanded slot as `Vec<Option<elem>>` (the write side wraps every slot in
661/// `Option`). Allowing `Option<scalar>` here would ask for `Vec<Option<Option<…>>>`,
662/// which has no `TryFromSexp` impl.
663///
664/// `pub(super)` so `enum_expansion.rs` can reuse it.
665pub(super) fn is_bare_reader_scalar_ty(ty: &syn::Type) -> bool {
666    is_known_scalar_ty(ty, READER_SCALAR_NAMES)
667}
668
669/// True if `ty` is a known scalar path, or `Option<known-scalar>`.
670///
671/// These are exactly the field types for which the from-R reader can pull a
672/// column out as `Vec<ty>` via `TryFromSexp` (scalar `Single` fields and
673/// `[T; N]` fixed-array elements, neither of which adds an `Option` wrapper).
674///
675/// `pub(super)` so `enum_expansion.rs` can reuse it.
676pub(super) fn is_reader_scalar_ty(ty: &syn::Type) -> bool {
677    if is_bare_reader_scalar_ty(ty) {
678        return true;
679    }
680    // Option<scalar>
681    if let syn::Type::Path(tp) = ty
682        && let Some(seg) = tp.path.segments.last()
683        && seg.ident == "Option"
684        && let syn::PathArguments::AngleBracketed(args) = &seg.arguments
685        && let Some(syn::GenericArgument::Type(inner)) = args.args.first()
686    {
687        return is_bare_reader_scalar_ty(inner);
688    }
689    false
690}
691
692/// True if `ty`'s last path segment is the bare ident `String` (path-identity
693/// check, same convention as `classify_field_type`).
694fn is_string_ty(ty: &syn::Type) -> bool {
695    if let syn::Type::Path(tp) = ty
696        && let Some(seg) = tp.path.segments.last()
697        && #[allow(non_exhaustive_omitted_patterns)] match seg.arguments {
    syn::PathArguments::None => true,
    _ => false,
}matches!(seg.arguments, syn::PathArguments::None)
698    {
699        return seg.ident == "String";
700    }
701    false
702}
703
704/// Number of *type* arguments on `ty`'s last path segment (0 when not
705/// angle-bracketed). Rejects `HashMap<K, V, S>` custom-hasher maps from the
706/// reader path — the `Vec<HashMap<String, V>>: TryFromSexp` impl only covers
707/// the default hasher.
708fn generic_type_arg_count(ty: &syn::Type) -> usize {
709    if let syn::Type::Path(tp) = ty
710        && let Some(seg) = tp.path.segments.last()
711        && let syn::PathArguments::AngleBracketed(args) = &seg.arguments
712    {
713        return args
714            .args
715            .iter()
716            .filter(|a| #[allow(non_exhaustive_omitted_patterns)] match a {
    syn::GenericArgument::Type(_) => true,
    _ => false,
}matches!(a, syn::GenericArgument::Type(_)))
717            .count();
718    }
719    0
720}
721
722/// True if a resolved struct field can be read back out of an R `data.frame`.
723///
724/// Determines whether the struct gets a generated `try_from_dataframe` reader.
725/// Each shape's reader is the inverse of its column-expansion write rule:
726/// - `Single` scalar: one column read as `Vec<ty>` (excludes `as_list` and
727///   opaque set/collection columns — those classify as `Single` but lack
728///   `Vec<_>: TryFromSexp`). A datetime column (`jiff::Timestamp`,
729///   `Option<time::Date>`, …) reads back the same way.
730/// - `Single` factor: `FactorVec<ty>` validates levels and reads owned variants.
731/// - `Single` map column (`HashMap<String, V>` / `BTreeMap<String, V>`): one
732///   VECSXP list-of-named-lists column read whole via `Vec<map>: TryFromSexp`
733///   — the exact inverse of the `Vec<map>: IntoR` write shape (#764). Gated
734///   to `String` keys + reader-scalar values at resolve time (`map_reader`).
735/// - `Single` owned list-column: `Vec<scalar>` / `Box<[scalar]>` stored as a
736///   VECSXP list-column; the reader deserialises each row's element via
737///   `Vec<elem>: TryFromSexp` and `.into()`-converts to the field type (#809).
738/// - `ExpandedFixed` (`[T; N]`): `N` columns regrouped into the array.
739/// - `ExpandedVec` / `AutoExpandVec` (`Vec<T>`): suffixed `Option` columns
740///   flattened back per row (bare-scalar elements only).
741/// - `Struct` (nested `DataFrameRow`): always eligible — the reader routes the
742///   un-prefixed sub-frame through the inner type's `DataFrameRowConvert`, which
743///   degrades to a clear runtime error if the inner shape itself has no reader.
744///
745/// Borrowed expansion origins (`&[T]` / `&[T; N]`) are not readable (owned R data
746/// can't produce a borrow) — flagged via `readable` at resolve time.
747fn field_reader_capable(rf: &ResolvedField) -> bool {
748    match rf {
749        ResolvedField::Single(d) => {
750            !d.needs_into_list
751                && (d.is_factor
752                    || is_reader_scalar_ty(&d.ty)
753                    || datetime_column_ty(&d.ty).is_some()
754                    || d.map_reader
755                    || d.list_elem_ty
756                        .as_ref()
757                        .is_some_and(is_bare_reader_scalar_ty))
758        }
759        ResolvedField::ExpandedFixed(d) => d.readable && is_reader_scalar_ty(&d.elem_ty),
760        ResolvedField::ExpandedVec(d) => d.readable && is_bare_reader_scalar_ty(&d.elem_ty),
761        ResolvedField::AutoExpandVec(d) => d.readable && is_bare_reader_scalar_ty(&d.elem_ty),
762        ResolvedField::Struct(_) => true,
763        ResolvedField::Map(d) => {
764            is_bare_reader_scalar_ty(&d.key_ty) && is_bare_reader_scalar_ty(&d.val_ty)
765        }
766    }
767}
768
769/// True if `ty` is a borrowed reference (`&[T]`, `&[T; N]`, `&str`, …). Such
770/// expansion fields can't be reconstructed by value in the R→Rust reader.
771pub(super) fn field_is_borrowed_ref(ty: &syn::Type) -> bool {
772    #[allow(non_exhaustive_omitted_patterns)] match ty {
    syn::Type::Reference(_) => true,
    _ => false,
}matches!(ty, syn::Type::Reference(_))
773}
774// endregion
775
776// region: Resolved field model (struct path)
777
778/// A resolved struct field ready for codegen -- determines how this field maps
779/// to DataFrame companion struct columns.
780///
781/// Each variant represents a different expansion strategy:
782/// - `Single`: one field -> one `Vec<T>` column
783/// - `ExpandedFixed`: `[T; N]` -> N columns (`name_1..name_N`) at compile time
784/// - `ExpandedVec`: `Vec<T>` + `width = N` -> N `Vec<Option<T>>` columns
785/// - `AutoExpandVec`: `Vec<T>` + `expand` -> dynamic column count at runtime
786enum ResolvedField {
787    /// Single column: `name → Vec<ty>`.
788    Single(Box<SingleFieldData>),
789    /// Expanded fixed array: `name: [T; N]` → `name_1..name_N`.
790    ExpandedFixed(Box<ExpandedFixedData>),
791    /// Expanded variable vec with pinned width: `name: Vec<T>` + `width = N`.
792    ExpandedVec(Box<ExpandedVecData>),
793    /// Auto-expanded `Vec<T>`/`Box<[T]>`: column count determined at runtime from max row length.
794    AutoExpandVec(Box<AutoExpandVecData>),
795    /// Struct field whose inner type implements `DataFrameRow` (issue #485).
796    /// Companion holds `Vec<Inner>`; `into_data_frame` calls `Inner::to_dataframe`
797    /// and flattens columns under the `<base>_` prefix.
798    Struct(Box<StructFieldData>),
799    /// Non-String-keyed `HashMap<K,V>` / `BTreeMap<K,V>` field (#919).
800    /// Expands to two parallel list-columns `<base>_keys` / `<base>_values`,
801    /// each a `Vec<Vec<K>>` / `Vec<Vec<V>>` (VECSXP of typed vectors). The
802    /// reader zips `keys[i]` with `values[i]` back into the map type.
803    Map(Box<MapFieldData>),
804}
805
806/// Data for [`ResolvedField::Map`] (struct path, non-String-keyed maps, #919).
807struct MapFieldData {
808    /// Rust field name (for access on the row type).
809    rust_name: syn::Ident,
810    /// Column name base — keys col = `<base>_keys`, values col = `<base>_values`.
811    base_name: String,
812    /// Key type `K`.
813    key_ty: syn::Type,
814    /// Value type `V`.
815    val_ty: syn::Type,
816    /// Full map type `HashMap<K,V>` / `BTreeMap<K,V>` (used in reader zip).
817    map_ty: syn::Type,
818    /// Index in tuple struct (None for named).
819    tuple_index: Option<syn::Index>,
820}
821
822/// Data for [`ResolvedField::Single`].
823struct SingleFieldData {
824    /// Rust field name (for access).
825    rust_name: syn::Ident,
826    /// Column name in the DataFrame.
827    col_name: syn::Ident,
828    /// Column name string.
829    col_name_str: String,
830    /// Field type stored in the companion `Vec<#ty>`: the field's Rust type, also
831    /// for `#[dataframe(as_list)]` on a struct-typed field (see
832    /// `needs_into_list`), so the companion never holds R objects.
833    ty: syn::Type,
834    /// Index in tuple struct (None for named).
835    tuple_index: Option<syn::Index>,
836    /// `#[dataframe(as_list)]` on a struct-typed field (#485 workaround).
837    /// When `true`, the frame assembly builds the list-column with
838    /// `into_list_column`, which converts each value via `IntoList::into_list()`
839    /// straight into the rooted column (#1748).
840    needs_into_list: bool,
841    /// `Some(elem)` when this Single field is an un-annotated *owned* collection
842    /// (`Vec<scalar>` / `Box<[scalar]>`) stored as an opaque list-column (#809).
843    /// The reader deserialises the list-column back into the owned collection per
844    /// row via `Vec<elem>: TryFromSexp` then `.into()` to the field container type.
845    /// `None` for scalar Single, `as_list`, opaque `Map`/set columns, and borrowed
846    /// `&[T]` (not readable).
847    list_elem_ty: Option<syn::Type>,
848    /// `true` when this Single field is a reader-capable map column (#764):
849    /// `HashMap<String, V>` / `BTreeMap<String, V>` with a reader-scalar `V`
850    /// and no custom hasher. The column is read whole as `Vec<#ty>` via the
851    /// `Vec<map>: TryFromSexp` list-of-named-lists impl — the same `pull_col`
852    /// path scalar Singles use, so it only widens the capability gate.
853    map_reader: bool,
854    /// A unit-only enum stored as one factor column via `UnitEnumFactor`.
855    is_factor: bool,
856}
857
858/// Data for [`ResolvedField::ExpandedFixed`].
859struct ExpandedFixedData {
860    /// Rust field name.
861    rust_name: syn::Ident,
862    /// Base column name (before suffix).
863    base_name: String,
864    /// Element type T.
865    elem_ty: syn::Type,
866    /// Array length N.
867    len: usize,
868    /// Index in tuple struct.
869    tuple_index: Option<syn::Index>,
870    /// Whether the field can be reconstructed by value in the R→Rust reader.
871    /// `false` for a borrowed origin (`&[T; N]`) — owned R data can't produce a
872    /// borrow, so the struct gets no reader (see [`field_reader_capable`]).
873    readable: bool,
874    /// The field is `&[T; N]`: its elements are cloned out, not moved.
875    borrowed: bool,
876}
877
878/// Data for [`ResolvedField::ExpandedVec`].
879struct ExpandedVecData {
880    /// Rust field name.
881    rust_name: syn::Ident,
882    /// Base column name.
883    base_name: String,
884    /// Element type T.
885    elem_ty: syn::Type,
886    /// Pinned width.
887    width: usize,
888    /// Index in tuple struct.
889    tuple_index: Option<syn::Index>,
890    /// Whether the field can be reconstructed by value in the R→Rust reader.
891    /// `false` for a borrowed origin (`&[T]`); `Vec<T>` / `Box<[T]>` are readable
892    /// (the reader collects a `Vec<T>` and `.into()`-converts to the field type).
893    readable: bool,
894    /// The field is `&[T]`: its elements are cloned out, not moved.
895    borrowed: bool,
896}
897
898/// Data for [`ResolvedField::Struct`].
899///
900/// A struct field whose inner type implements `DataFrameRow`. The companion
901/// struct holds `Vec<Inner>` (the same type users already pass into
902/// `to_dataframe(vec![...])`). At `into_data_frame()` time the inner rows are
903/// converted via `Inner::to_dataframe` → `into_named_columns()`, prefixed with
904/// `<base_name>_`, and pushed into the parent data.frame.
905struct StructFieldData {
906    /// Rust field name (for access on the row type).
907    rust_name: syn::Ident,
908    /// Companion struct field name (ident).
909    col_name: syn::Ident,
910    /// Column name base used as the R-side prefix (`<base>_<inner_col>`).
911    col_name_str: String,
912    /// Inner struct type (used for `to_dataframe` dispatch + DataFrameRow assertion).
913    inner_ty: syn::Type,
914    /// Index in tuple struct (None for named).
915    tuple_index: Option<syn::Index>,
916}
917
918/// Data for [`ResolvedField::AutoExpandVec`].
919struct AutoExpandVecData {
920    /// Rust field name (for row access).
921    rust_name: syn::Ident,
922    /// Companion struct field name (ident).
923    col_name: syn::Ident,
924    /// Column name base string (for suffixed column names).
925    col_name_str: String,
926    /// Element type T.
927    elem_ty: syn::Type,
928    /// Container type for companion struct (`Vec<T>` or `Box<[T]>`).
929    container_ty: syn::Type,
930    /// Index in tuple struct.
931    tuple_index: Option<syn::Index>,
932    /// Whether the field can be reconstructed by value in the R→Rust reader.
933    /// `false` for a borrowed origin (`&[T]`); `Vec<T>` / `Box<[T]>` are readable.
934    readable: bool,
935    /// The field is `&[T]`: its elements are cloned out, not moved.
936    borrowed: bool,
937}
938
939/// The same `as_factor` shapes are accepted on struct and enum fields. The
940/// generated conversion checks `UnitEnumFactor` on the selected type.
941fn validate_factor_field_type(ty: &syn::Type) -> syn::Result<()> {
942    match classify_field_type(ty)? {
943        FieldTypeKind::Struct { .. } => Ok(()),
944        _ => Err(syn::Error::new_spanned(
945            ty,
946            "`as_factor` is only valid on bare-ident enum/struct types; \
947             use `as_list` for generic or complex types, or remove \
948             `as_factor` for scalar fields",
949        )),
950    }
951}
952
953/// Resolve a struct field into a [`ResolvedField`], applying field attributes.
954///
955/// Combines the field's `#[dataframe(...)]` attributes with its type classification
956/// to determine the codegen strategy:
957/// - `skip` -> returns `None`
958/// - `as_list` / `as_factor` -> `Single` (suppresses expansion)
959/// - `FixedArray` -> `ExpandedFixed` (compile-time expansion to N columns)
960/// - `VariableVec`/`BoxedSlice`/`BorrowedSlice` + `width` -> `ExpandedVec`
961/// - `VariableVec`/`BoxedSlice`/`BorrowedSlice` + `expand` -> `AutoExpandVec`
962/// - Everything else -> `Single`
963///
964/// Returns `Err` if `width` or `expand` is used on an incompatible type.
965fn resolve_struct_field(
966    field: &syn::Field,
967    index: usize,
968    is_tuple: bool,
969) -> syn::Result<Option<ResolvedField>> {
970    let field_attrs = parse_field_attrs(field)?;
971
972    if field_attrs.skip {
973        return Ok(None);
974    }
975
976    let rust_name = if is_tuple {
977        match ::quote::__private::IdentFragmentAdapter(&index) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("_{}", index)
978    } else {
979        field.ident.as_ref().unwrap().clone()
980    };
981
982    let col_name_str = field_attrs
983        .rename
984        .clone()
985        .unwrap_or_else(|| crate::naming::ident_name(&rust_name));
986    let col_name = crate::naming::name_ident(&col_name_str);
987
988    let tuple_index = if is_tuple {
989        Some(syn::Index::from(index))
990    } else {
991        None
992    };
993
994    let ty = &field.ty;
995    // Propagate classification errors (e.g. Option<T>, Arc<T>) when as_list is
996    // not set.  The as_list branch below uses `.ok()` to suppress errors.
997    let kind = classify_field_type(ty);
998
999    if field_attrs.as_factor {
1000        validate_factor_field_type(ty)?;
1001        return Ok(Some(ResolvedField::Single(Box::new(SingleFieldData {
1002            rust_name,
1003            col_name,
1004            col_name_str,
1005            ty: ty.clone(),
1006            tuple_index,
1007            needs_into_list: false,
1008            list_elem_ty: None,
1009            map_reader: false,
1010            is_factor: true,
1011        }))));
1012    }
1013
1014    // as_list suppresses expansion. For struct-typed fields (#485 opt-out), the
1015    // companion stores the struct values and the frame assembly converts each
1016    // one via `IntoList::into_list()` straight into the rooted list-column
1017    // (`into_list_column`). For non-struct as_list fields, the existing
1018    // behavior is preserved: the field type is serialized natively (this
1019    // requires `Vec<#ty>: IntoR`).
1020    if field_attrs.as_list {
1021        // Use `.ok()` here: `as_list` is an explicit opt-in, so wrapper types
1022        // like `Option<T>` / `Arc<T>` are allowed — they become opaque list-
1023        // columns. Any classification error is suppressed and treated as non-Struct.
1024        let needs_into_list = #[allow(non_exhaustive_omitted_patterns)] match classify_field_type(ty).ok() {
    Some(FieldTypeKind::Struct { .. }) => true,
    _ => false,
}matches!(
1025            classify_field_type(ty).ok(),
1026            Some(FieldTypeKind::Struct { .. })
1027        );
1028        return Ok(Some(ResolvedField::Single(Box::new(SingleFieldData {
1029            rust_name,
1030            col_name,
1031            col_name_str,
1032            ty: ty.clone(),
1033            tuple_index,
1034            needs_into_list,
1035            list_elem_ty: None,
1036            map_reader: false,
1037            is_factor: false,
1038        }))));
1039    }
1040
1041    match kind? {
1042        FieldTypeKind::FixedArray(elem_ty, len) => Ok(Some(ResolvedField::ExpandedFixed(
1043            Box::new(ExpandedFixedData {
1044                rust_name,
1045                base_name: col_name_str,
1046                elem_ty: elem_ty.clone(),
1047                len,
1048                tuple_index,
1049                readable: !field_is_borrowed_ref(ty),
1050                borrowed: field_is_borrowed_ref(ty),
1051            }),
1052        ))),
1053        FieldTypeKind::VariableVec(elem_ty)
1054        | FieldTypeKind::BoxedSlice(elem_ty)
1055        | FieldTypeKind::BorrowedSlice(elem_ty) => {
1056            if (field_attrs.width.is_some() || field_attrs.expand) && is_raw_scalar_ty(elem_ty) {
1057                let attr = if field_attrs.width.is_some() {
1058                    "width"
1059                } else {
1060                    "expand"
1061                };
1062                return Err(raw_na_column_error(
1063                    elem_ty,
1064                    &::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("`{0}` pads shorter rows with NA",
                attr))
    })format!("`{attr}` pads shorter rows with NA"),
1065                    &::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("Use `u16` or `i32` elements for integer columns, or drop `{0}` to keep each value as one raw-vector cell of a list-column.",
                attr))
    })format!(
1066                        "Use `u16` or `i32` elements for integer columns, or drop `{attr}` \
1067                         to keep each value as one raw-vector cell of a list-column."
1068                    ),
1069                ));
1070            }
1071            if let Some(width) = field_attrs.width {
1072                Ok(Some(ResolvedField::ExpandedVec(Box::new(
1073                    ExpandedVecData {
1074                        rust_name,
1075                        base_name: col_name_str,
1076                        elem_ty: elem_ty.clone(),
1077                        width,
1078                        tuple_index,
1079                        readable: !field_is_borrowed_ref(ty),
1080                        borrowed: field_is_borrowed_ref(ty),
1081                    },
1082                ))))
1083            } else if field_attrs.expand {
1084                Ok(Some(ResolvedField::AutoExpandVec(Box::new(
1085                    AutoExpandVecData {
1086                        rust_name,
1087                        col_name,
1088                        col_name_str,
1089                        elem_ty: elem_ty.clone(),
1090                        container_ty: ty.clone(),
1091                        tuple_index,
1092                        readable: !field_is_borrowed_ref(ty),
1093                        borrowed: field_is_borrowed_ref(ty),
1094                    },
1095                ))))
1096            } else {
1097                // No expansion — keep as opaque single column (list-column on R side).
1098                // Readable owned collections (`Vec<scalar>` / `Box<[scalar]>`) record
1099                // the element type for the list-column reader (#809). Borrowed `&[T]`
1100                // is not readable (can't produce a borrow from owned R data).
1101                Ok(Some(ResolvedField::Single(Box::new(SingleFieldData {
1102                    rust_name,
1103                    col_name,
1104                    col_name_str,
1105                    ty: ty.clone(),
1106                    tuple_index,
1107                    needs_into_list: false,
1108                    list_elem_ty: if field_is_borrowed_ref(ty) {
1109                        None
1110                    } else {
1111                        Some((*elem_ty).clone())
1112                    },
1113                    map_reader: false,
1114                    is_factor: false,
1115                }))))
1116            }
1117        }
1118        // Struct-in-struct flattening (issue #485): inner type must implement
1119        // `DataFrameRow`. Flattening happens at `into_data_frame()` time; the
1120        // companion stores `Vec<Inner>`. `as_list` opts out (handled above).
1121        FieldTypeKind::Struct { inner_ty } => {
1122            if field_attrs.width.is_some() {
1123                return Err(syn::Error::new_spanned(
1124                    ty,
1125                    "`width` is only valid on `Vec<T>`, `Box<[T]>`, or `&[T]` fields",
1126                ));
1127            }
1128            if field_attrs.expand {
1129                return Err(syn::Error::new_spanned(
1130                    ty,
1131                    "`expand`/`unnest` is only valid on `[T; N]`, `Vec<T>`, `Box<[T]>`, or `&[T]` fields",
1132                ));
1133            }
1134            Ok(Some(ResolvedField::Struct(Box::new(StructFieldData {
1135                rust_name,
1136                col_name,
1137                col_name_str,
1138                inner_ty: inner_ty.clone(),
1139                tuple_index,
1140            }))))
1141        }
1142        kind
1143        @ (FieldTypeKind::Scalar | FieldTypeKind::OptionScalar | FieldTypeKind::Map { .. }) => {
1144            if field_attrs.width.is_some() {
1145                return Err(syn::Error::new_spanned(
1146                    ty,
1147                    "`width` is only valid on `Vec<T>`, `Box<[T]>`, or `&[T]` fields",
1148                ));
1149            }
1150            if field_attrs.expand {
1151                return Err(syn::Error::new_spanned(
1152                    ty,
1153                    "`expand`/`unnest` is only valid on `[T; N]`, `Vec<T>`, `Box<[T]>`, or `&[T]` fields",
1154                ));
1155            }
1156            // Struct-path map fields:
1157            //
1158            // - `String`-keyed + reader-scalar value + 2 type args (default hasher):
1159            //   write as one opaque list-of-named-lists column (`Vec<map>: IntoR`).
1160            //   Reader-capable via `Vec<map>: TryFromSexp` (#764). Falls through
1161            //   to `Single` with `map_reader: true` — unchanged.
1162            //
1163            // - Non-String bare-reader-scalar key + bare-reader-scalar value + 2 type args:
1164            //   expand to two parallel list-columns `<base>_keys` / `<base>_values` (#919).
1165            //   `Vec<Vec<K>>: IntoR` and `Vec<Vec<V>>: IntoR` work via the generic
1166            //   `Vec<Vec<T>>` impl (any `T` with `Vec<T>: IntoR`). Float keys (`f32`/`f64`)
1167            //   are also bare-reader-scalar but lack `Eq + Hash` / `Ord`, so reject them
1168            //   with a clear error.
1169            //
1170            // - Custom hasher (3+ type args): fall through to `Single` with no reader
1171            //   (keeps existing behaviour for `HashMap<K, V, S>`).
1172            //
1173            // - Non-scalar key or value: emit a clear error directing to `as_list`.
1174            if let FieldTypeKind::Map { key_ty, val_ty } = kind {
1175                let two_args = generic_type_arg_count(ty) == 2;
1176                if is_string_ty(key_ty) && is_reader_scalar_ty(val_ty) && two_args {
1177                    // String-keyed — existing path (#764).
1178                    return Ok(Some(ResolvedField::Single(Box::new(SingleFieldData {
1179                        rust_name,
1180                        col_name,
1181                        col_name_str,
1182                        ty: ty.clone(),
1183                        tuple_index,
1184                        needs_into_list: false,
1185                        list_elem_ty: None,
1186                        map_reader: true,
1187                        is_factor: false,
1188                    }))));
1189                }
1190                // Float key check: f32/f64 classify as bare_reader_scalar but are
1191                // neither Eq+Hash nor Ord, so they can't be a map key at all.
1192                let is_float_ty = |t: &syn::Type| -> bool {
1193                    if let syn::Type::Path(tp) = t
1194                        && let Some(seg) = tp.path.segments.last()
1195                        && #[allow(non_exhaustive_omitted_patterns)] match seg.arguments {
    syn::PathArguments::None => true,
    _ => false,
}matches!(seg.arguments, syn::PathArguments::None)
1196                    {
1197                        let n = seg.ident.to_string();
1198                        return n == "f32" || n == "f64";
1199                    }
1200                    false
1201                };
1202                if is_float_ty(key_ty) {
1203                    return Err(syn::Error::new_spanned(
1204                        ty,
1205                        "HashMap/BTreeMap with float keys is not supported \
1206                         (f32/f64 are not Eq+Hash/Ord); use a newtype wrapper \
1207                         or `#[dataframe(as_list)]`",
1208                    ));
1209                }
1210                if two_args && is_bare_reader_scalar_ty(key_ty) && is_bare_reader_scalar_ty(val_ty)
1211                {
1212                    // Non-String bare-scalar keyed — new parallel _keys/_values path (#919).
1213                    return Ok(Some(ResolvedField::Map(Box::new(MapFieldData {
1214                        rust_name,
1215                        base_name: col_name_str,
1216                        key_ty: key_ty.clone(),
1217                        val_ty: val_ty.clone(),
1218                        map_ty: ty.clone(),
1219                        tuple_index,
1220                    }))));
1221                }
1222                if two_args
1223                    && (!is_bare_reader_scalar_ty(key_ty) || !is_bare_reader_scalar_ty(val_ty))
1224                {
1225                    // Non-scalar key or value (and not String-keyed) — opaque, no reader.
1226                    // Fall through to Single below.
1227                }
1228                // 3+ type args (custom hasher) or non-scalar — Single with no reader.
1229            }
1230            let map_reader = false;
1231            Ok(Some(ResolvedField::Single(Box::new(SingleFieldData {
1232                rust_name,
1233                col_name,
1234                col_name_str,
1235                ty: ty.clone(),
1236                tuple_index,
1237                needs_into_list: false,
1238                list_elem_ty: None,
1239                map_reader,
1240                is_factor: false,
1241            }))))
1242        }
1243    }
1244}
1245// endregion
1246
1247// region: Top-level dispatch
1248
1249/// Derive `DataFrameRow`: generates a companion DataFrame type with collection fields.
1250///
1251/// # Requirements
1252///
1253/// For enums: all variants must have named fields. A struct row needs no other
1254/// trait; nothing generated converts a row to a list.
1255///
1256/// # Generated Items
1257///
1258/// For a struct `Measurement { time: f64, value: f64 }`:
1259/// - Struct `MeasurementDataFrame { time: Vec<f64>, value: Vec<f64> }`
1260/// - `impl IntoDataFrame for MeasurementDataFrame` (rows → R `data.frame`)
1261/// - `impl ColumnarFrame for MeasurementDataFrame` (rows ↔ the pure-Rust companion)
1262/// - `impl From<Vec<Measurement>> for MeasurementDataFrame`
1263/// - `impl IntoIterator for MeasurementDataFrame`
1264///
1265/// For an enum:
1266/// - Companion struct with `Vec<Option<T>>` columns (field-name union)
1267/// - Optional tag column for variant discrimination
1268/// - `impl From<Vec<Enum>> for EnumDataFrame`
1269/// - `impl IntoDataFrame for EnumDataFrame`
1270/// - `impl ColumnarFrame for EnumDataFrame`
1271/// - `impl DataFrameRowSplit for Enum` (the split representation behind
1272///   `IntoDataFrameSplit`)
1273///
1274/// # Public surface (which verbs to call)
1275///
1276/// - Rows → R `data.frame`: `rows.into_dataframe()?` (`/_par`) or
1277///   `rows.wrap_data_frame()`, from `IntoDataFrame` / `AsDataFrameExt`.
1278/// - R `data.frame` → rows: `Vec::<Row>::from_dataframe(&df)?` (`/_par`) from
1279///   `FromDataFrame`, or the one-call `Row::try_from_dataframe(sexp)` reader.
1280/// - Rows ↔ the pure-Rust columnar companion: the `ColumnarFrame` trait
1281///   (`<Row>DataFrame::from_rows` / `from_rows_par` / `into_rows`), or the `std`
1282///   `Vec<Row>: Into<companion>` / companion `IntoIterator`.
1283/// - Enums: `rows.into_dataframe_split()` (one `data.frame` per variant) from
1284///   `IntoDataFrameSplit`, implemented via the hidden `DataFrameRowSplit` bridge
1285///   on the enum type.
1286///
1287/// All the traits above are re-exported from `miniextendr_api::prelude`. The row
1288/// type also carries two `#[doc(hidden)]` helpers: `to_dataframe(rows) -> companion`,
1289/// retained only because the struct-flatten / nested-enum write paths build a
1290/// nested companion via `Inner::to_dataframe(..)` without naming its type, and
1291/// `to_dataframe_split(rows)`, the body holder behind the `DataFrameRowSplit` bridge.
1292///
1293/// # Attributes
1294///
1295/// - `#[dataframe(name = "CustomName")]` — Custom companion type name
1296/// - `#[dataframe(align)]` — Enum alignment mode (accepted but implicit)
1297/// - `#[dataframe(tag = "col")]` — Add variant discriminator column
1298pub fn derive_dataframe_row(input: DeriveInput) -> syn::Result<TokenStream> {
1299    let row_name = &input.ident;
1300
1301    // Allow lifetime parameters (needed for &[T] borrowed slice fields).
1302    // Allow type parameters on unit-only enums (all variants are unit) — the
1303    // companion struct has no field columns to type-parameterise, and the three
1304    // unit-enum impls (UnitEnumFactor, IntoR, IntoList) handle generics via the
1305    // split path in enum_expansion.rs.
1306    // Reject type and const parameters for everything else.
1307    let has_type_params = input.generics.type_params().next().is_some();
1308    let has_const_params = input.generics.const_params().next().is_some();
1309    if has_type_params || has_const_params {
1310        let is_unit_only_enum = #[allow(non_exhaustive_omitted_patterns)] match &input.data {
    Data::Enum(e) if
        e.variants.iter().all(|v|
                #[allow(non_exhaustive_omitted_patterns)] match v.fields {
                    Fields::Unit => true,
                    _ => false,
                }) => true,
    _ => false,
}matches!(&input.data, Data::Enum(e)
1311            if e.variants.iter().all(|v| matches!(v.fields, Fields::Unit)));
1312        if !is_unit_only_enum {
1313            return Err(syn::Error::new_spanned(
1314                &input.generics,
1315                "DataFrameRow does not support type or const generic parameters",
1316            ));
1317        }
1318    }
1319
1320    // Parse attributes
1321    let attrs = parse_dataframe_attrs(&input)?;
1322
1323    let df_name = attrs
1324        .name
1325        .clone()
1326        .unwrap_or_else(|| match ::quote::__private::IdentFragmentAdapter(&row_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}DataFrame", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}DataFrame", row_name));
1327
1328    let base = match &input.data {
1329        Data::Struct(data) => {
1330            // `align` is a no-op on structs (only semantically meaningful for enums)
1331            derive_struct_dataframe(row_name, &input, data, &df_name, &attrs)
1332        }
1333        Data::Enum(data) => {
1334            // align is implicit for enums — accept but don't require
1335            derive_enum_dataframe(row_name, &input, data, &df_name, &attrs)
1336        }
1337        Data::Union(_) => Err(syn::Error::new_spanned(
1338            row_name,
1339            "DataFrameRow does not support unions",
1340        )),
1341    }?;
1342
1343    // Generate IntoR for the companion DataFrame type so it can be returned
1344    // directly from #[miniextendr] functions. This ensures both the standalone
1345    // #[derive(DataFrameRow)] path and the #[miniextendr(dataframe)] path
1346    // produce identical output.
1347    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
1348    Ok({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&base, &mut _s);
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_r");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoR");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "type");
            ::quote::__private::push_ident(&mut _s, "Error");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Infallible");
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "inline");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "try_into_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Infallible");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Ok");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "self");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            _s
                        });
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "inline");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "unsafe");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "try_into_sexp_unchecked");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Infallible");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "try_into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "inline");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "into_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "convert");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "ColumnSource");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_column_list");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "self");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "inline");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "unsafe");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "into_sexp_unchecked");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "convert");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "ColumnSource");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_column_list");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "self");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            _s
        });
    _s
}quote::quote! {
1349        #base
1350
1351        impl #impl_generics ::miniextendr_api::into_r::IntoR for #df_name #ty_generics #where_clause {
1352            type Error = ::core::convert::Infallible;
1353
1354            #[inline]
1355            fn try_into_sexp(self) -> ::core::result::Result<::miniextendr_api::SEXP, ::core::convert::Infallible> {
1356                ::core::result::Result::Ok(self.into_sexp())
1357            }
1358
1359            #[inline]
1360            unsafe fn try_into_sexp_unchecked(self) -> ::core::result::Result<::miniextendr_api::SEXP, ::core::convert::Infallible> {
1361                self.try_into_sexp()
1362            }
1363
1364            #[inline]
1365            fn into_sexp(self) -> ::miniextendr_api::SEXP {
1366                ::miniextendr_api::convert::ColumnSource::into_column_list(self).into_sexp()
1367            }
1368
1369            #[inline]
1370            unsafe fn into_sexp_unchecked(self) -> ::miniextendr_api::SEXP {
1371                ::miniextendr_api::convert::ColumnSource::into_column_list(self).into_sexp()
1372            }
1373        }
1374    })
1375}
1376// endregion
1377
1378// region: Field-type bounds (shared by the struct and enum paths)
1379//
1380// The derive asks of a field type only what turning that field into columns
1381// needs: a column's `IntoR`, `IntoList` for an `as_list` value, `DataFrameRow`
1382// for a flattened struct. Everything else it emits for a field type exists
1383// only where the type allows it: the companion's `Debug` / `Clone`, the rows
1384// iterator that rebuilds `skip` fields with `Default`, and the parallel fill
1385// behind `from_rows_par` carry conditional bounds
1386// (`crate::naming::conditional_bound_lifetime`) instead.
1387
1388/// `where` clause: `where_clause`'s predicates, then `for<'__mx_cond> ty: bound`
1389/// for each `(ty, bound)` pair.
1390pub(super) fn conditional_where(
1391    where_clause: Option<&syn::WhereClause>,
1392    bounds: &[(TokenStream, TokenStream)],
1393) -> TokenStream {
1394    let binder = crate::naming::conditional_bound_lifetime();
1395    let mut preds: Vec<TokenStream> = where_clause
1396        .into_iter()
1397        .flat_map(|wc| wc.predicates.iter())
1398        .map(|p| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&p, &mut _s);
    _s
}quote! { #p })
1399        .collect();
1400    preds.extend(
1401        bounds
1402            .iter()
1403            .map(|(ty, bound)| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&binder, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&bound, &mut _s);
    _s
}quote! { for<#binder> #ty: #bound }),
1404    );
1405    if preds.is_empty() {
1406        TokenStream::new()
1407    } else {
1408        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "where");
    {
        use ::quote::__private::ext::*;
        let mut _first = true;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut preds, i) = preds.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let preds =
                match preds.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            if !_first { ::quote::__private::push_comma(&mut _s); }
            _first = false;
            ::quote::ToTokens::to_tokens(&preds, &mut _s);
        }
    }
    _s
}quote! { where #(#preds),* }
1409    }
1410}
1411
1412/// Keep lifetimes erased by column expansion or skipped fields in the companion.
1413/// Columns that still borrow already carry their lifetimes; only missing ones
1414/// need a marker. This adds no data column or element-type trait requirements.
1415pub(super) fn companion_lifetime_marker(
1416    generics: &syn::Generics,
1417    fields: &mut Vec<(syn::Ident, TokenStream)>,
1418) -> (TokenStream, TokenStream) {
1419    use syn::visit_mut::VisitMut;
1420
1421    struct MissingLifetimes(Vec<syn::Lifetime>);
1422    impl VisitMut for MissingLifetimes {
1423        fn visit_lifetime_mut(&mut self, lifetime: &mut syn::Lifetime) {
1424            self.0.retain(|candidate| candidate.ident != lifetime.ident);
1425        }
1426    }
1427    let mut missing = MissingLifetimes(
1428        generics
1429            .lifetimes()
1430            .map(|param| param.lifetime.clone())
1431            .collect(),
1432    );
1433    for (_, ty) in fields.iter() {
1434        missing.visit_type_mut(&mut syn::parse2::<syn::Type>(ty.clone()).unwrap());
1435    }
1436    if missing.0.is_empty() {
1437        return (TokenStream::new(), TokenStream::new());
1438    }
1439    let lifetimes = missing.0;
1440    let mut name = ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("__mx_lifetimes"))
            }), ::quote::__private::Option::None)format_ident!("__mx_lifetimes");
1441    while fields.iter().any(|(field, _)| field == &name) {
1442        name = match ::quote::__private::IdentFragmentAdapter(&name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_", name);
1443    }
1444    let ty = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "marker");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "PhantomData");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut lifetimes, i) = lifetimes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let lifetimes =
                        match lifetimes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::__private::push_and(&mut _s);
                    ::quote::ToTokens::to_tokens(&lifetimes, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::core::marker::PhantomData<(#(&#lifetimes (),)*)> };
1445    fields.push((name.clone(), ty.clone()));
1446    (
1447        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { #name: #ty, },
1448        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "marker");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "PhantomData");
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { #name: ::core::marker::PhantomData, },
1449    )
1450}
1451
1452/// `Debug` and `Clone` for a companion, each implemented only when every field
1453/// type has it. `#[derive(Debug, Clone)]` would demand both of every column's
1454/// element type (#2013). `fields` are the companion's fields with their types.
1455pub(super) fn companion_debug_clone(
1456    df_name: &syn::Ident,
1457    generics: &syn::Generics,
1458    fields: &[(syn::Ident, TokenStream)],
1459) -> TokenStream {
1460    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
1461    let bounds = |bound: TokenStream| -> Vec<(TokenStream, TokenStream)> {
1462        fields
1463            .iter()
1464            .map(|(_, ty)| (ty.clone(), bound.clone()))
1465            .collect()
1466    };
1467    let debug_where = conditional_where(where_clause, &bounds({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "fmt");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Debug");
    _s
}quote! { ::core::fmt::Debug }));
1468    let clone_where = conditional_where(where_clause, &bounds({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    _s
}quote! { ::core::clone::Clone }));
1469    let df_name_str = df_name.to_string();
1470    let idents: Vec<&syn::Ident> = fields.iter().map(|(ident, _)| ident).collect();
1471    let names: Vec<String> = idents
1472        .iter()
1473        .map(|ident| crate::naming::ident_name(ident))
1474        .collect();
1475    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "automatically_derived");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unused_lifetimes");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "fmt");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Debug");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&debug_where, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "fmt");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__f");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "fmt");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Formatter");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_lifetime(&mut _s, "\'_");
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "fmt");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__f");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "debug_struct");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&df_name_str, &mut _s);
                            _s
                        });
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut names, i) = names.quote_into_iter();
                        let has_iter = has_iter | i;
                        #[allow(unused_mut)]
                        let (mut idents, i) = idents.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let names =
                                match names.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            let idents =
                                match idents.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "field");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&names, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_and(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "self");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::ToTokens::to_tokens(&idents, &mut _s);
                                    _s
                                });
                        }
                    }
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "finish");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "automatically_derived");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unused_lifetimes");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&clone_where, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let mut _first = true;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut idents, i) = idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                #[allow(unused_mut)]
                                let (mut idents, i) = idents.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let idents =
                                        match idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    let idents =
                                        match idents.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    if !_first { ::quote::__private::push_comma(&mut _s); }
                                    _first = false;
                                    ::quote::ToTokens::to_tokens(&idents, &mut _s);
                                    ::quote::__private::push_colon(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "clone");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Clone");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "clone");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_and(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "self");
                                            ::quote::__private::push_dot(&mut _s);
                                            ::quote::ToTokens::to_tokens(&idents, &mut _s);
                                            _s
                                        });
                                }
                            }
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
1476        #[automatically_derived]
1477        #[allow(unused_lifetimes)]
1478        impl #impl_generics ::core::fmt::Debug for #df_name #ty_generics #debug_where {
1479            fn fmt(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1480                __f.debug_struct(#df_name_str)
1481                    #(.field(#names, &self.#idents))*
1482                    .finish()
1483            }
1484        }
1485
1486        #[automatically_derived]
1487        #[allow(unused_lifetimes)]
1488        impl #impl_generics ::core::clone::Clone for #df_name #ty_generics #clone_where {
1489            fn clone(&self) -> Self {
1490                Self { #(#idents: ::core::clone::Clone::clone(&self.#idents)),* }
1491            }
1492        }
1493    }
1494}
1495
1496/// The parallel column fill of a companion: `ParallelColumns` with `body` as
1497/// `from_rows_parallel(rows)`, implemented only where `bounds` hold (see
1498/// `miniextendr_api::dataframe::ParallelColumns`). Emitted only when
1499/// miniextendr-api has `rayon`; pair it with [`from_rows_par_override`].
1500pub(super) fn parallel_columns_impl(
1501    df_name: &syn::Ident,
1502    row_name: &syn::Ident,
1503    generics: &syn::Generics,
1504    bounds: &[(TokenStream, TokenStream)],
1505    body: TokenStream,
1506) -> TokenStream {
1507    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
1508    let where_tokens = conditional_where(where_clause, bounds);
1509    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__dataframe_row_when_rayon");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "allow");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "unused_lifetimes");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "impl");
            ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ParallelColumns");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::ToTokens::to_tokens(&df_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::ToTokens::to_tokens(&where_tokens, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "fn");
                    ::quote::__private::push_ident(&mut _s,
                        "from_rows_parallel");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "rows");
                            ::quote::__private::push_colon(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            _s
                        });
                    ::quote::__private::push_rarrow(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&body, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
1510        // The `#[cfg(feature = "rayon")]` gate lives on the api-side macro
1511        // (evaluated against miniextendr-api's own features), not here —
1512        // stamping the cfg into the consumer crate trips `unexpected_cfgs`
1513        // wherever the derive is used without a `rayon` feature (#1117).
1514        ::miniextendr_api::__dataframe_row_when_rayon! {
1515            #[allow(unused_lifetimes)]
1516            impl #impl_generics ::miniextendr_api::dataframe::ParallelColumns<#row_name #ty_generics>
1517                for #df_name #ty_generics #where_tokens
1518            {
1519                fn from_rows_parallel(rows: ::std::vec::Vec<#row_name #ty_generics>) -> Self {
1520                    #body
1521                }
1522            }
1523        }
1524    }
1525}
1526
1527/// The `from_rows_par` override of a companion's `ColumnarFrame` impl: the
1528/// companion's `ParallelColumns` impl where it applies, `from_rows` otherwise
1529/// (`miniextendr_api::dataframe::FromRowsParProbe`).
1530pub(super) fn from_rows_par_override(row_ty: TokenStream) -> TokenStream {
1531    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__dataframe_row_when_rayon");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "allow");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "clippy");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "needless_borrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from_rows_par");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&row_ty, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_pound(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "allow");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "unused_imports");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_ident(&mut _s, "use");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s,
                                "FromRowsParParallel");
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_underscore(&mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s,
                                "FromRowsParSequential");
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_underscore(&mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "dataframe");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "FromRowsParProbe");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Self");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&row_ty, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "new");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "fill_columns");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "rows");
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
1532        ::miniextendr_api::__dataframe_row_when_rayon! {
1533            // The explicit borrow is what lets lookup fall back to the
1534            // sequential arm; it is not needless.
1535            #[allow(clippy::needless_borrow)]
1536            fn from_rows_par(rows: ::std::vec::Vec<#row_ty>) -> Self {
1537                #[allow(unused_imports)]
1538                use ::miniextendr_api::dataframe::{
1539                    FromRowsParParallel as _, FromRowsParSequential as _,
1540                };
1541                (&::miniextendr_api::dataframe::FromRowsParProbe::<Self, #row_ty>::new())
1542                    .fill_columns(rows)
1543            }
1544        }
1545    }
1546}
1547
1548/// `<ty as Clone>::clone`, spanned at `ty`: a type without `Clone` is then
1549/// reported at the user's field instead of at the derive.
1550pub(super) fn spanned_clone_fn(ty: &syn::Type) -> TokenStream {
1551    let span = syn::spanned::Spanned::span(ty);
1552    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "as");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "clone");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "Clone");
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "clone");
    _s
}quote_spanned! {span=> <#ty as ::core::clone::Clone>::clone }
1553}
1554
1555/// Bind each element of fixed-array field value `access` to its own variable
1556/// in `elems`: moved out of an owned array (indexing would need `Copy`), cloned
1557/// out of a borrowed one, which is the only way to own an element behind a
1558/// reference.
1559pub(super) fn fixed_array_elems(
1560    access: &TokenStream,
1561    borrowed: bool,
1562    elem_ty: &syn::Type,
1563    elems: &[syn::Ident],
1564) -> TokenStream {
1565    if borrowed {
1566        let clone = spanned_clone_fn(elem_ty);
1567        let lets: Vec<TokenStream> = elems
1568            .iter()
1569            .enumerate()
1570            .map(|(i, elem)| {
1571                let idx = syn::Index::from(i);
1572                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&elem, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&clone, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&idx, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let #elem = #clone(&#access[#idx]); }
1573            })
1574            .collect();
1575        {
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut lets, i) = lets.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let lets =
                match lets.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&lets, &mut _s);
        }
    }
    _s
}quote! { #(#lets)* }
1576    } else {
1577        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut elems, i) = elems.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let elems =
                        match elems.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&elems, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&access, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let [#(#elems),*] = #access; }
1578    }
1579}
1580
1581/// The elements of an expanded `Vec<T>` / `Box<[T]>` / `&[T]` field value
1582/// `access` as an iterator of owned `T`: moved out of an owned container,
1583/// cloned out of a borrowed slice. `IntoIterator::into_iter` is called by path
1584/// so a `Box<[T]>` iterates by value in every edition.
1585pub(super) fn owned_elems_iter(
1586    access: &TokenStream,
1587    borrowed: bool,
1588    elem_ty: &syn::Type,
1589) -> TokenStream {
1590    if borrowed {
1591        // A closure, not the clone fn itself: the closure is `FnMut` whatever
1592        // `elem_ty` implements, so a missing `Clone` is reported once, at the
1593        // field, instead of again wherever the iterator is used.
1594        let clone = spanned_clone_fn(elem_ty);
1595        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "IntoIterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&access, &mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_elem");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
            ::quote::__private::push_or(&mut _s);
            ::quote::ToTokens::to_tokens(&clone, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__mx_elem");
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    _s
}quote! {
1596            ::core::iter::Iterator::map(
1597                ::core::iter::IntoIterator::into_iter(#access),
1598                |__mx_elem: &#elem_ty| #clone(__mx_elem),
1599            )
1600        }
1601    } else {
1602        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoIterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    _s
}quote! { ::core::iter::IntoIterator::into_iter(#access) }
1603    }
1604}
1605
1606/// Bind the first `elems.len()` elements of a `width = N` field value `access`
1607/// to `Option<T>` variables (`None` past its end; elements past `N` are
1608/// dropped), through iterator variable `iter`.
1609pub(super) fn width_elems(
1610    access: &TokenStream,
1611    borrowed: bool,
1612    elem_ty: &syn::Type,
1613    iter: &syn::Ident,
1614    elems: &[syn::Ident],
1615) -> TokenStream {
1616    let elems_iter = owned_elems_iter(access, borrowed, elem_ty);
1617    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&iter, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&elems_iter, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut elems, i) = elems.quote_into_iter();
        let has_iter = has_iter | i;
        #[allow(unused_mut)]
        let (mut iter, i) = iter.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let elems =
                match elems.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            let iter =
                match iter.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::ToTokens::to_tokens(&elems, &mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Iterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "next");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::ToTokens::to_tokens(&iter, &mut _s);
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
        }
    }
    _s
}quote! {
1618        let mut #iter = #elems_iter;
1619        #(let #elems = ::core::iter::Iterator::next(&mut #iter);)*
1620    }
1621}
1622
1623/// The variables [`fixed_array_elems`] / [`width_elems`] bind for the `n`
1624/// columns of the field `key` names. Leading underscores are dropped from `key`
1625/// so the variables stay snake case (`_0` gives `__mxe1_0`).
1626pub(super) fn expanded_elem_idents(key: &str, n: usize) -> Vec<syn::Ident> {
1627    let key = key.trim_start_matches('_');
1628    (1..=n)
1629        .map(|k| match ::quote::__private::IdentFragmentAdapter(&k) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&key) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__mxe{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__mxe{}_{}", k, key))
1630        .collect()
1631}
1632// endregion
1633
1634// region: Struct path (existing logic, extracted)
1635
1636/// Convert a column (`access`: the companion's field, or the borrowed fill's
1637/// local) without adding R objects to the companion: `as_list` uses the rooted
1638/// list builder, `as_factor` uses `UnitEnumFactor`, and ordinary columns
1639/// convert the whole `Vec` through `IntoR`.
1640fn column_sexp(
1641    access: &TokenStream,
1642    ty: &syn::Type,
1643    needs_into_list: bool,
1644    is_factor: bool,
1645) -> TokenStream {
1646    if needs_into_list {
1647        let into_list_column = list_column_fn(ty, false);
1648        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&into_list_column, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    _s
}quote! { #into_list_column(#access) }
1649    } else if is_factor {
1650        let span = syn::spanned::Spanned::span(ty);
1651        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "IntoR");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "into_sexp");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "miniextendr_api");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "factor");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "FactorVec");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_lt_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&ty, &mut _s);
            ::quote::__private::push_gt_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "from");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::ToTokens::to_tokens(&access, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote_spanned! {span=>
1652            ::miniextendr_api::IntoR::into_sexp(
1653                ::miniextendr_api::factor::FactorVec::<#ty>::from(#access)
1654            )
1655        }
1656    } else {
1657        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoR");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_sexp");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::IntoR::into_sexp(#access) }
1658    }
1659}
1660
1661/// The local a fill (the owned `From<Vec<Row>>`, or the borrowed
1662/// `DataFrameRowBorrow`) keeps column `name` in. Prefixed, so no column can
1663/// shadow the fill's own bindings (`rows`, `row`, `len`, `__mx_row`,
1664/// `__mx_len`): a field named `len` used to break the owned fill.
1665///
1666/// The call-site span keeps `non_snake_case` off the user's field: the
1667/// prefixed name of a field `_x` (`__mx_col__x`) is not snake case.
1668pub(super) fn column_local(name: &syn::Ident) -> syn::Ident {
1669    match ::quote::__private::IdentFragmentAdapter(&name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mx_col_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(proc_macro2::Span::call_site())),
}format_ident!("__mx_col_{}", name, span = proc_macro2::Span::call_site())
1670}
1671
1672/// The element type of a borrowed fill's string column, with the `String` type
1673/// it borrows from: `&str` for a `String` column, `Option<&str>` for an
1674/// `Option<String>` one, `None` for every other column. These columns are
1675/// written from the row's own string (`StringColumn`, which only
1676/// `std::string::String` implements), and `Vec<&str>` / `Vec<Option<&str>>`
1677/// convert to the same character vector as the owned column.
1678pub(super) fn borrowed_string_column(ty: &syn::Type) -> Option<(TokenStream, &syn::Type)> {
1679    if is_string_ty(ty) {
1680        return Some(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "primitive");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "str");
    _s
}quote! { &::core::primitive::str }, ty));
1681    }
1682    let inner = option_payload(ty)?;
1683    is_string_ty(inner).then(|| {
1684        (
1685            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "primitive");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "str");
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::core::option::Option<&::core::primitive::str> },
1686            inner,
1687        )
1688    })
1689}
1690
1691/// The `&str` of a `String` value (`value`: an expression of type `&String`).
1692pub(super) fn column_str(value: TokenStream) -> TokenStream {
1693    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "StringColumn");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_column_str");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&value, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::dataframe::StringColumn::__mx_column_str(#value) }
1694}
1695
1696/// `StringColumn::__mx_column_str` as a function, for `Option::map`.
1697pub(super) fn column_str_fn() -> TokenStream {
1698    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "StringColumn");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_column_str");
    _s
}quote! { ::miniextendr_api::dataframe::StringColumn::__mx_column_str }
1699}
1700
1701/// `into_list_column::<#ty>` (or `into_option_list_column::<#ty>`, for a column
1702/// with absent rows), spanned at the field type: a type without `IntoList` is
1703/// then reported at the field instead of at the derive.
1704pub(super) fn list_column_fn(ty: &syn::Type, optional: bool) -> TokenStream {
1705    let span = syn::spanned::Spanned::span(ty);
1706    let name = if optional {
1707        "into_option_list_column"
1708    } else {
1709        "into_list_column"
1710    };
1711    let func = syn::Ident::new(name, span);
1712    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "list");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&func, &mut _s);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=> ::miniextendr_api::list::#func::<#ty> }
1713}
1714
1715/// Generate `DataFrameRow` expansion for struct types.
1716///
1717/// Produces:
1718/// - A companion struct `{Name}DataFrame` with `Vec<T>` columns
1719/// - `impl IntoDataFrame for {Name}DataFrame`
1720/// - `impl From<Vec<{Name}>> for {Name}DataFrame`
1721/// - `impl IntoIterator` (for named structs without expansion)
1722/// - Associated methods: `to_dataframe`, `from_dataframe`, `from_rows`, `from_rows_par`
1723///
1724/// Handles fixed-array expansion (`[T; N]`), pinned-width Vec expansion
1725/// (`Vec<T>` + `width`), and auto-expand Vec (`Vec<T>` + `expand`).
1726fn derive_struct_dataframe(
1727    row_name: &syn::Ident,
1728    input: &DeriveInput,
1729    data: &syn::DataStruct,
1730    df_name: &syn::Ident,
1731    attrs: &DataFrameAttrs,
1732) -> syn::Result<TokenStream> {
1733    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
1734    // The companion and its row iterator take the row struct's visibility: their
1735    // `IntoIterator` / `Iterator` impls name the row type as `Item`, so a `pub`
1736    // companion over a private row is E0446 ("private type in public interface").
1737    let vis = &input.vis;
1738
1739    let is_tuple_struct = #[allow(non_exhaustive_omitted_patterns)] match &data.fields {
    Fields::Unnamed(_) => true,
    _ => false,
}matches!(&data.fields, Fields::Unnamed(_));
1740    let is_unit_struct = #[allow(non_exhaustive_omitted_patterns)] match &data.fields {
    Fields::Unit => true,
    _ => false,
}matches!(&data.fields, Fields::Unit);
1741
1742    // Resolve fields through the new FieldAttrs + type classification system.
1743    let resolved: Vec<ResolvedField> = match &data.fields {
1744        Fields::Named(fields) => {
1745            let mut out = Vec::new();
1746            for (i, f) in fields.named.iter().enumerate() {
1747                if let Some(rf) = resolve_struct_field(f, i, false)? {
1748                    out.push(rf);
1749                }
1750            }
1751            out
1752        }
1753        Fields::Unnamed(fields) => {
1754            let mut out = Vec::new();
1755            for (i, f) in fields.unnamed.iter().enumerate() {
1756                if let Some(rf) = resolve_struct_field(f, i, true)? {
1757                    out.push(rf);
1758                }
1759            }
1760            out
1761        }
1762        Fields::Unit => ::alloc::vec::Vec::new()vec![],
1763    };
1764
1765    // Check whether any field uses expansion — affects whether we can generate
1766    // IntoIterator (expanded fields change the companion struct shape).
1767    let has_expansion = resolved
1768        .iter()
1769        .any(|rf| !#[allow(non_exhaustive_omitted_patterns)] match rf {
    ResolvedField::Single(..) => true,
    _ => false,
}matches!(rf, ResolvedField::Single(..)));
1770    // Track which Rust fields were skipped, with their types (for destructure
1771    // patterns and the rows iterator's `Default` bounds).
1772    let skipped_fields: Vec<(syn::Ident, syn::Type)> = match &data.fields {
1773        Fields::Named(fields) => fields
1774            .named
1775            .iter()
1776            .filter_map(|f| {
1777                let fa = parse_field_attrs(f).ok()?;
1778                if fa.skip {
1779                    Some((f.ident.as_ref().unwrap().clone(), f.ty.clone()))
1780                } else {
1781                    None
1782                }
1783            })
1784            .collect(),
1785        _ => ::alloc::vec::Vec::new()vec![],
1786    };
1787
1788    let has_tag = attrs.tag.is_some();
1789    let row_name_str = row_name.to_string();
1790
1791    // region: Build flat column lists from resolved fields
1792    // Each resolved field may produce 1..N columns.
1793    struct FlatCol {
1794        /// Companion struct field name.
1795        df_field: syn::Ident,
1796        /// Column name string in the R data frame.
1797        col_name_str: String,
1798        /// Type of the companion Vec<T>.
1799        vec_elem_ty: syn::Type,
1800        /// `#[dataframe(as_list)]` on a struct-typed field — companion stores
1801        /// the struct values, converted to a list-column at frame assembly.
1802        /// The `from_rows_par` pre-pass clones these sequentially instead of
1803        /// scatter-writing (the struct need not implement `Default`).
1804        needs_into_list: bool,
1805        /// Convert this column through `UnitEnumFactor`.
1806        is_factor: bool,
1807    }
1808
1809    let mut flat_cols: Vec<FlatCol> = Vec::new();
1810
1811    for rf in &resolved {
1812        match rf {
1813            ResolvedField::Single(data) => {
1814                flat_cols.push(FlatCol {
1815                    df_field: data.col_name.clone(),
1816                    col_name_str: data.col_name_str.clone(),
1817                    vec_elem_ty: data.ty.clone(),
1818                    needs_into_list: data.needs_into_list,
1819                    is_factor: data.is_factor,
1820                });
1821            }
1822            ResolvedField::ExpandedFixed(data) => {
1823                for i in 1..=data.len {
1824                    let name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
1825                    flat_cols.push(FlatCol {
1826                        df_field: match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&i) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i),
1827                        col_name_str: name,
1828                        vec_elem_ty: data.elem_ty.clone(),
1829                        needs_into_list: false,
1830                        is_factor: false,
1831                    });
1832                }
1833            }
1834            ResolvedField::ExpandedVec(data) => {
1835                for i in 1..=data.width {
1836                    let name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
1837                    let elem_ty = &data.elem_ty;
1838                    let opt_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "core");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "option");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Option");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::core::option::Option<#elem_ty>);
1839                    flat_cols.push(FlatCol {
1840                        df_field: match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&i) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i),
1841                        col_name_str: name,
1842                        vec_elem_ty: opt_ty,
1843                        needs_into_list: false,
1844                        is_factor: false,
1845                    });
1846                }
1847            }
1848            // AutoExpandVec / Struct do not produce FlatCols — handled separately.
1849            ResolvedField::AutoExpandVec(..) | ResolvedField::Struct(..) => {}
1850            // Map (#919): two parallel list-columns `<base>_keys` / `<base>_values`.
1851            // Each is a `Vec<Vec<K>>` / `Vec<Vec<V>>` (VECSXP of typed vectors).
1852            ResolvedField::Map(data) => {
1853                let keys_col_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
1854                let vals_col_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
1855                let key_ty = &data.key_ty;
1856                let val_ty = &data.val_ty;
1857                let keys_vec_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "std");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&key_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<#key_ty>);
1858                let vals_vec_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "std");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&val_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<#val_ty>);
1859                flat_cols.push(FlatCol {
1860                    df_field: match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_keys", data.base_name),
1861                    col_name_str: keys_col_name,
1862                    vec_elem_ty: keys_vec_ty,
1863                    needs_into_list: false,
1864                    is_factor: false,
1865                });
1866                flat_cols.push(FlatCol {
1867                    df_field: match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_values", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_values", data.base_name),
1868                    col_name_str: vals_col_name,
1869                    vec_elem_ty: vals_vec_ty,
1870                    needs_into_list: false,
1871                    is_factor: false,
1872                });
1873            }
1874        }
1875    }
1876    // endregion
1877
1878    // region: Collect auto-expand fields
1879    struct AutoExpandCol {
1880        /// Companion struct field name.
1881        df_field: syn::Ident,
1882        /// Container type (Vec<T> or Box<[T]>).
1883        container_ty: syn::Type,
1884    }
1885
1886    let auto_expand_cols: Vec<AutoExpandCol> = resolved
1887        .iter()
1888        .filter_map(|rf| {
1889            if let ResolvedField::AutoExpandVec(data) = rf {
1890                Some(AutoExpandCol {
1891                    df_field: crate::naming::name_ident(&data.col_name_str),
1892                    container_ty: data.container_ty.clone(),
1893                })
1894            } else {
1895                None
1896            }
1897        })
1898        .collect();
1899    let has_auto_expand = !auto_expand_cols.is_empty();
1900    // endregion
1901
1902    // region: Collect struct (DataFrameRow-flattened) fields (#485)
1903    //
1904    // Only the codegen-time bits are mirrored here — `rust_name` / `tuple_index`
1905    // are read directly off `ResolvedField::Struct` at the per-row pushes site.
1906    struct StructCol {
1907        df_field: syn::Ident,
1908        col_name_str: String,
1909        inner_ty: syn::Type,
1910    }
1911
1912    let struct_cols: Vec<StructCol> = resolved
1913        .iter()
1914        .filter_map(|rf| {
1915            if let ResolvedField::Struct(data) = rf {
1916                Some(StructCol {
1917                    df_field: data.col_name.clone(),
1918                    col_name_str: data.col_name_str.clone(),
1919                    inner_ty: data.inner_ty.clone(),
1920                })
1921            } else {
1922                None
1923            }
1924        })
1925        .collect();
1926    let has_struct = !struct_cols.is_empty();
1927
1928    // Any `#[dataframe(as_list)]` on a struct-typed field (#485 opt-out) keeps
1929    // the struct in the companion and becomes a list-column only at frame
1930    // assembly. The struct need not implement `Default`, so several codegen
1931    // branches special-case it: IntoIterator generation is skipped, and
1932    // `from_rows_par` fills the column in a sequential pre-pass.
1933    let has_into_list_struct = resolved
1934        .iter()
1935        .any(|rf| #[allow(non_exhaustive_omitted_patterns)] match rf {
    ResolvedField::Single(d) if d.needs_into_list => true,
    _ => false,
}matches!(rf, ResolvedField::Single(d) if d.needs_into_list));
1936    // endregion
1937
1938    // region: Companion struct
1939    let tag_field_decl = if has_tag {
1940        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { pub _tag: ::std::vec::Vec<::std::string::String>, }
1941    } else {
1942        TokenStream::new()
1943    };
1944
1945    // The column fields with their types: declared below, and bounding the
1946    // companion's conditional `Debug` / `Clone`.
1947    let mut column_fields: Vec<(syn::Ident, TokenStream)> = flat_cols
1948        .iter()
1949        .map(|fc| {
1950            let ty = &fc.vec_elem_ty;
1951            (fc.df_field.clone(), {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::std::vec::Vec<#ty> })
1952        })
1953        .collect();
1954    for ac in &auto_expand_cols {
1955        let cty = &ac.container_ty;
1956        column_fields.push((ac.df_field.clone(), {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&cty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::std::vec::Vec<#cty> }));
1957    }
1958    for sc in &struct_cols {
1959        let ity = &sc.inner_ty;
1960        column_fields.push((sc.df_field.clone(), {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ity, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::std::vec::Vec<#ity> }));
1961    }
1962    let df_fields_tokens: Vec<TokenStream> = column_fields
1963        .iter()
1964        .map(|(name, ty)| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { pub #name: #ty })
1965        .collect();
1966
1967    let has_len_field =
1968        flat_cols.is_empty() && auto_expand_cols.is_empty() && struct_cols.is_empty() && !has_tag;
1969    let len_field_decl = if has_len_field {
1970        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::__private::push_ident(&mut _s, "_len");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_ident(&mut _s, "usize");
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { pub _len: usize, }
1971    } else {
1972        TokenStream::new()
1973    };
1974
1975    let mut companion_fields: Vec<(syn::Ident, TokenStream)> = Vec::new();
1976    if has_tag {
1977        companion_fields.push((
1978            ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"),
1979            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::std::vec::Vec<::std::string::String> },
1980        ));
1981    }
1982    if has_len_field {
1983        companion_fields.push((::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_len"))
            }), ::quote::__private::Option::None)format_ident!("_len"), {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "usize");
    _s
}quote! { usize }));
1984    }
1985    companion_fields.extend(column_fields);
1986    let (phantom_field, phantom_init) =
1987        companion_lifetime_marker(&input.generics, &mut companion_fields);
1988    let companion_debug_clone = companion_debug_clone(df_name, &input.generics, &companion_fields);
1989
1990    let dataframe_struct = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&vis, &mut _s);
    ::quote::__private::push_ident(&mut _s, "struct");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_field_decl, &mut _s);
            ::quote::ToTokens::to_tokens(&len_field_decl, &mut _s);
            ::quote::ToTokens::to_tokens(&phantom_field, &mut _s);
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut df_fields_tokens, i) =
                    df_fields_tokens.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let df_fields_tokens =
                        match df_fields_tokens.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&df_fields_tokens, &mut _s);
                }
            }
            _s
        });
    ::quote::ToTokens::to_tokens(&companion_debug_clone, &mut _s);
    _s
}quote! {
1991        #vis struct #df_name #impl_generics #where_clause {
1992            #tag_field_decl
1993            #len_field_decl
1994            #phantom_field
1995            #(#df_fields_tokens),*
1996        }
1997
1998        #companion_debug_clone
1999    };
2000    // endregion
2001
2002    // region: IntoDataFrame
2003    //
2004    // One generator assembles the column list for both column sources: the
2005    // companion (`ColumnSource::into_column_list`, which reads `self.<col>`)
2006    // and the borrowed fill (`DataFrameRowBorrow`, which reads its locals), so
2007    // the two build the same frame: names, order, column types.
2008    let length_ref = if has_tag {
2009        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { self._tag.len() }
2010    } else if !flat_cols.is_empty() {
2011        let first = &flat_cols[0].df_field;
2012        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&first, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { self.#first.len() }
2013    } else if !auto_expand_cols.is_empty() {
2014        let first = &auto_expand_cols[0].df_field;
2015        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&first, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { self.#first.len() }
2016    } else if !struct_cols.is_empty() {
2017        let first = &struct_cols[0].df_field;
2018        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&first, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { self.#first.len() }
2019    } else {
2020        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "_len");
    _s
}quote! { self._len }
2021    };
2022
2023    // `col` reads column `name`. With `borrowed_rows`, an auto-expand column
2024    // holds slices of the rows' containers, whose elements are cloned out,
2025    // instead of the containers themselves.
2026    let column_list_body = |col: &dyn Fn(&syn::Ident) -> TokenStream,
2027                            length_ref: TokenStream,
2028                            borrowed_rows: bool|
2029     -> TokenStream {
2030        let tag_col = col(&::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"));
2031
2032        // Each pair protects its SEXP via `__scope.protect_raw` so previously-built
2033        // column SEXPs survive subsequent column allocations. Pre-fix the raw
2034        // `vec![(name, into_sexp(...)), ...]` left every SEXP unrooted across the
2035        // next column's allocations — UAF under gctorture
2036        // (reviews/2026-05-07-gctorture-audit.md).
2037        let tag_pair = if let Some(ref tag_name) = attrs.tag {
2038            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_name, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "protect_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoR");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_sexp");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&tag_col, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { (#tag_name, __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#tag_col))), }
2039        } else {
2040            TokenStream::new()
2041        };
2042
2043        let df_pairs: Vec<TokenStream> = flat_cols
2044            .iter()
2045            .map(|fc| {
2046                let name_str = &fc.col_name_str;
2047                let column = column_sexp(
2048                    &col(&fc.df_field),
2049                    &fc.vec_elem_ty,
2050                    fc.needs_into_list,
2051                    fc.is_factor,
2052                );
2053                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&name_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "protect_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&column, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote! { (#name_str, __scope.protect_raw(#column)) }
2054            })
2055            .collect();
2056
2057        let mut length_checks: Vec<TokenStream> = flat_cols
2058            .iter()
2059            .map(|fc| {
2060                let column = col(&fc.df_field);
2061                let name_str = &fc.col_name_str;
2062                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "assert");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_eq_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "_n_rows");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s,
                "\"column length mismatch in {}: column `{}` has length {} but expected {}\"");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "stringify");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&name_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "_n_rows");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2063                    ::core::assert!(
2064                        #column.len() == _n_rows,
2065                        "column length mismatch in {}: column `{}` has length {} but expected {}",
2066                        ::core::stringify!(#df_name),
2067                        #name_str,
2068                        #column.len(),
2069                        _n_rows,
2070                    );
2071                }
2072            })
2073            .collect();
2074        for sc in &struct_cols {
2075            let column = col(&sc.df_field);
2076            let name_str = &sc.col_name_str;
2077            length_checks.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "assert");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_eq_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "_n_rows");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s,
                "\"column length mismatch in {}: struct column `{}` has length {} but expected {}\"");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "stringify");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&name_str, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "len");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "_n_rows");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2078                ::core::assert!(
2079                    #column.len() == _n_rows,
2080                    "column length mismatch in {}: struct column `{}` has length {} but expected {}",
2081                    ::core::stringify!(#df_name),
2082                    #name_str,
2083                    #column.len(),
2084                    _n_rows,
2085                );
2086            });
2087        }
2088
2089        if has_auto_expand || has_struct {
2090            // Dynamic pair building: iterate resolved fields in order,
2091            // emitting static pairs for flat columns and runtime-expanded
2092            // pairs for auto-expand fields.
2093            let tag_push_pair = if let Some(ref tag_name) = attrs.tag {
2094                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&tag_name, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&tag_col, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2095                    __df_pairs.push((#tag_name.to_string(), __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#tag_col))));
2096                }
2097            } else {
2098                TokenStream::new()
2099            };
2100
2101            let pair_pushes: Vec<TokenStream> = resolved
2102                .iter()
2103                .map(|rf| match rf {
2104                    ResolvedField::Single(data) => {
2105                        let col_name_str = &data.col_name_str;
2106                        let column = column_sexp(
2107                            &col(&data.col_name),
2108                            &data.ty,
2109                            data.needs_into_list,
2110                            data.is_factor,
2111                        );
2112                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&column, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2113                            __df_pairs.push((
2114                                #col_name_str.to_string(),
2115                                __scope.protect_raw(#column),
2116                            ));
2117                        }
2118                    }
2119                    ResolvedField::ExpandedFixed(data) => {
2120                        let pushes: Vec<TokenStream> = (1..=data.len)
2121                            .map(|i| {
2122                                let name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
2123                                let column = col(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&i) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i));
2124                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&name, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&column, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2125                                    __df_pairs.push((
2126                                        #name.to_string(),
2127                                        __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#column)),
2128                                    ));
2129                                }
2130                            })
2131                            .collect();
2132                        {
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut pushes, i) = pushes.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let pushes =
                match pushes.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&pushes, &mut _s);
        }
    }
    _s
}quote! { #(#pushes)* }
2133                    }
2134                    ResolvedField::ExpandedVec(data) => {
2135                        let pushes: Vec<TokenStream> = (1..=data.width)
2136                            .map(|i| {
2137                                let name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, i))
    })format!("{}_{}", data.base_name, i);
2138                                let column = col(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&i) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i));
2139                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&name, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&column, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2140                                    __df_pairs.push((
2141                                        #name.to_string(),
2142                                        __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#column)),
2143                                    ));
2144                                }
2145                            })
2146                            .collect();
2147                        {
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut pushes, i) = pushes.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let pushes =
                match pushes.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&pushes, &mut _s);
        }
    }
    _s
}quote! { #(#pushes)* }
2148                    }
2149                    ResolvedField::AutoExpandVec(data) => {
2150                        let column = col(&data.col_name);
2151                        let col_name_str = &data.col_name_str;
2152                        let elem_ty = &data.elem_ty;
2153                        let elems_iter = owned_elems_iter(
2154                            &{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row_vec");
    _s
}quote! { __row_vec },
2155                            data.borrowed || borrowed_rows,
2156                            elem_ty,
2157                        );
2158                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__auto");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&column, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__max");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__auto");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "v");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "v");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "max");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "unwrap_or");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "0");
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__cols");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "0");
                    ::quote::__private::push_dot2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__max");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_underscore(&mut _s);
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "with_capacity");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "_n_rows");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "collect");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_ident(&mut _s, "__row_vec");
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::push_ident(&mut _s, "__auto");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "__elems");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::ToTokens::to_tokens(&elems_iter, &mut _s);
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__col");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::push_ident(&mut _s, "__cols");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "iter_mut");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__col");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "push");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "iter");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Iterator");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "next");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_and(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "mut");
                                            ::quote::__private::push_ident(&mut _s, "__elems");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__col");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::push_ident(&mut _s, "__cols");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "enumerate");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__df_pairs");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__i");
                                            ::quote::__private::push_add(&mut _s);
                                            ::quote::__private::parse(&mut _s, "1");
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__scope");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "IntoR");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_ident(&mut _s, "__col");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
2159                            {
2160                                let __auto = #column;
2161                                let __max = __auto.iter().map(|v| v.len()).max().unwrap_or(0);
2162                                let mut __cols: ::std::vec::Vec<::std::vec::Vec<::core::option::Option<#elem_ty>>> = (0..__max)
2163                                    .map(|_| ::std::vec::Vec::with_capacity(_n_rows))
2164                                    .collect();
2165                                for __row_vec in __auto {
2166                                    let mut __elems = #elems_iter;
2167                                    for __col in __cols.iter_mut() {
2168                                        __col.push(::core::iter::Iterator::next(&mut __elems));
2169                                    }
2170                                }
2171                                for (__i, __col) in __cols.into_iter().enumerate() {
2172                                    __df_pairs.push((
2173                                        ::std::format!("{}_{}", #col_name_str, __i + 1),
2174                                        __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(__col)),
2175                                    ));
2176                                }
2177                            }
2178                        }
2179                    }
2180                    ResolvedField::Struct(data) => {
2181                        // Issue #485: convert `Vec<Inner>` via Inner::to_dataframe,
2182                        // extract its named columns, and push under `<base>_` prefix.
2183                        let column = col(&data.col_name);
2184                        let base_name_str = &data.col_name_str;
2185                        let inner_ty = &data.inner_ty;
2186                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__inner_df");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_dataframe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&column, &mut _s);
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__inner_cols");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "convert");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnSource");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_named_columns");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__inner_df");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__inner_col_name");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__inner_col_sexp");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::push_ident(&mut _s, "__inner_cols");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__df_pairs");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&base_name_str, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__inner_col_name");
                                            _s
                                        });
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__inner_col_sexp");
                                    ::quote::__private::push_comma(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
2187                            {
2188                                let __inner_df = <#inner_ty>::to_dataframe(#column);
2189                                // The inner column list is rooted in __scope, which keeps its
2190                                // columns alive across the later columns' allocations.
2191                                let __inner_cols = ::miniextendr_api::convert::ColumnSource::into_named_columns(
2192                                    __inner_df,
2193                                    &__scope,
2194                                );
2195                                for (__inner_col_name, __inner_col_sexp) in __inner_cols {
2196                                    __df_pairs.push((
2197                                        ::std::format!("{}_{}", #base_name_str, __inner_col_name),
2198                                        __inner_col_sexp,
2199                                    ));
2200                                }
2201                            }
2202                        }
2203                    }
2204                    // Map (#919): push two list-columns `<base>_keys` / `<base>_values`.
2205                    ResolvedField::Map(data) => {
2206                        let keys_col = col(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_keys", data.base_name));
2207                        let vals_col = col(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_values", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_values", data.base_name));
2208                        let keys_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", data.base_name))
    })format!("{}_keys", data.base_name);
2209                        let vals_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", data.base_name))
    })format!("{}_values", data.base_name);
2210                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&keys_name, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&keys_col, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__df_pairs");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&vals_name, &mut _s);
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__scope");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "IntoR");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&vals_col, &mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2211                            __df_pairs.push((
2212                                #keys_name.to_string(),
2213                                __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#keys_col)),
2214                            ));
2215                            __df_pairs.push((
2216                                #vals_name.to_string(),
2217                                __scope.protect_raw(::miniextendr_api::IntoR::into_sexp(#vals_col)),
2218                            ));
2219                        }
2220                    }
2221                })
2222                .collect();
2223
2224            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "_n_rows");
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&length_ref, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut length_checks, i) = length_checks.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let length_checks =
                match length_checks.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&length_checks, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "gc_protect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ProtectScope");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__df_pairs");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "string");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "String");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::ToTokens::to_tokens(&tag_push_pair, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut pair_pushes, i) = pair_pushes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let pair_pushes =
                        match pair_pushes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&pair_pushes, &mut _s);
                }
            }
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_raw_pairs");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__df_pairs");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_class_str");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"data.frame\"");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_row_names_int");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "_n_rows");
                    _s
                });
            _s
        });
    _s
}quote! {
2225                let _n_rows = #length_ref;
2226                #(#length_checks)*
2227                // SAFETY: the column list is only assembled on the R main thread.
2228                // ProtectScope keeps each column SEXP rooted across the
2229                // next column's allocations; from_raw_pairs writes them
2230                // into the parent VECSXP before we drop the scope.
2231                unsafe {
2232                    let __scope = ::miniextendr_api::gc_protect::ProtectScope::new();
2233                    let mut __df_pairs: ::std::vec::Vec<(
2234                        ::std::string::String,
2235                        ::miniextendr_api::SEXP,
2236                    )> = ::std::vec::Vec::new();
2237                    #tag_push_pair
2238                    #(#pair_pushes)*
2239                    ::miniextendr_api::list::List::from_raw_pairs(__df_pairs)
2240                        .set_class_str(&["data.frame"])
2241                        .set_row_names_int(_n_rows)
2242                }
2243            }
2244        } else {
2245            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "_n_rows");
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&length_ref, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut length_checks, i) = length_checks.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let length_checks =
                match length_checks.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&length_checks, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__scope");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "gc_protect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ProtectScope");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__pairs");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "str");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    _s
                });
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&tag_pair, &mut _s);
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut df_pairs, i) = df_pairs.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let df_pairs =
                                match df_pairs.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&df_pairs, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "list");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_raw_pairs");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__pairs");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_class_str");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"data.frame\"");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "set_row_names_int");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "_n_rows");
                    _s
                });
            _s
        });
    _s
}quote! {
2246                let _n_rows = #length_ref;
2247                #(#length_checks)*
2248                // SAFETY: see the auto-expand branch.
2249                unsafe {
2250                    let __scope = ::miniextendr_api::gc_protect::ProtectScope::new();
2251                    // Annotated, so a row with no columns and no tag (a unit
2252                    // struct) doesn't hit E0282 on the empty `vec![]`.
2253                    let __pairs: ::std::vec::Vec<(&str, ::miniextendr_api::SEXP)> = ::std::vec![
2254                        #tag_pair
2255                        #(#df_pairs),*
2256                    ];
2257                    ::miniextendr_api::list::List::from_raw_pairs(__pairs)
2258                    .set_class_str(&["data.frame"])
2259                    .set_row_names_int(_n_rows)
2260                }
2261            }
2262        }
2263    };
2264
2265    let companion_column_list = column_list_body(&|name| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    _s
}quote! { self.#name }, length_ref, false);
2266    let into_dataframe_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "convert");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ColumnSource");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "into_column_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&companion_column_list,
                        &mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
2267        impl #impl_generics ::miniextendr_api::convert::ColumnSource for #df_name #ty_generics #where_clause {
2268            fn into_column_list(self) -> ::miniextendr_api::List {
2269                #companion_column_list
2270            }
2271        }
2272    };
2273    // endregion
2274
2275    // region: DataFrameRowBorrow — the borrowed fill (#2307)
2276    //
2277    // One pass over `&[Row]` into locals with the companion's column types,
2278    // then the column assembly above. `String` / `Option<String>` columns
2279    // hold the rows' `&str`; every other value is cloned into its column. What
2280    // the fill needs of a field type (`Clone`, `StringColumn`) is the impl's
2281    // conditional `where` clause, so a row with a non-`Clone` field still
2282    // derives: the borrowed conversion just does not apply to it.
2283    let borrowed_local = |name: &syn::Ident| -> TokenStream {
2284        let local = column_local(name);
2285        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #local }
2286    };
2287    let clone_bound = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    _s
}quote! { ::core::clone::Clone };
2288    let string_bound = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "StringColumn");
    _s
}quote! { ::miniextendr_api::dataframe::StringColumn };
2289    let mut borrow_bounds: Vec<(TokenStream, TokenStream)> = Vec::new();
2290    let mut borrow_inits: Vec<TokenStream> = Vec::new();
2291    let mut borrow_pushes: Vec<TokenStream> = Vec::new();
2292    let mut borrow_column = |name: &syn::Ident, elem_ty: TokenStream| {
2293        let local = column_local(name);
2294        borrow_inits.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2295            let mut #local: ::std::vec::Vec<#elem_ty> = ::std::vec::Vec::with_capacity(__mx_len);
2296        });
2297        local
2298    };
2299    if has_tag {
2300        let local = borrow_column(
2301            &::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("_tag"))
            }), ::quote::__private::Option::None)format_ident!("_tag"),
2302            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_lifetime(&mut _s, "\'static");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "primitive");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "str");
    _s
}quote! { &'static ::core::primitive::str },
2303        );
2304        borrow_pushes.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&row_name_str, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #local.push(#row_name_str); });
2305    }
2306    for rf in &resolved {
2307        let (rust_name, tuple_index) = match rf {
2308            ResolvedField::Single(d) => (&d.rust_name, &d.tuple_index),
2309            ResolvedField::ExpandedFixed(d) => (&d.rust_name, &d.tuple_index),
2310            ResolvedField::ExpandedVec(d) => (&d.rust_name, &d.tuple_index),
2311            ResolvedField::AutoExpandVec(d) => (&d.rust_name, &d.tuple_index),
2312            ResolvedField::Struct(d) => (&d.rust_name, &d.tuple_index),
2313            ResolvedField::Map(d) => (&d.rust_name, &d.tuple_index),
2314        };
2315        // The field, borrowed from the row: `&__mx_row.<field>`.
2316        let field = match tuple_index {
2317            Some(idx) => {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_row");
            ::quote::__private::push_dot(&mut _s);
            ::quote::ToTokens::to_tokens(&idx, &mut _s);
            _s
        });
    _s
}quote! { (&__mx_row.#idx) },
2318            None => {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_row");
            ::quote::__private::push_dot(&mut _s);
            ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
            _s
        });
    _s
}quote! { (&__mx_row.#rust_name) },
2319        };
2320        match rf {
2321            ResolvedField::Single(data) => {
2322                let ty = &data.ty;
2323                let string_column = (!data.needs_into_list && !data.is_factor)
2324                    .then(|| borrowed_string_column(ty))
2325                    .flatten();
2326                if let Some((str_ty, string_ty)) = string_column {
2327                    let local = borrow_column(&data.col_name, str_ty);
2328                    let value = if option_payload(ty).is_some() {
2329                        let as_str = column_str_fn();
2330                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "as_ref");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&field, &mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&as_str, &mut _s);
            _s
        });
    _s
}quote! {
2331                            ::core::option::Option::map(::core::option::Option::as_ref(#field), #as_str)
2332                        }
2333                    } else {
2334                        column_str(field)
2335                    };
2336                    borrow_pushes.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&value, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #local.push(#value); });
2337                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&string_ty, &mut _s);
    _s
}quote! { #string_ty }, string_bound.clone()));
2338                } else {
2339                    let local = borrow_column(&data.col_name, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty });
2340                    borrow_pushes
2341                        .push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&field, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #local.push(::core::clone::Clone::clone(#field)); });
2342                    borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, clone_bound.clone()));
2343                }
2344            }
2345            ResolvedField::ExpandedFixed(data) => {
2346                let elem_ty = &data.elem_ty;
2347                let elems = expanded_elem_idents(
2348                    &crate::naming::unraw(&data.rust_name).to_string(),
2349                    data.len,
2350                );
2351                borrow_pushes.push(fixed_array_elems(&field, true, elem_ty, &elems));
2352                for (i, elem) in elems.iter().enumerate() {
2353                    let local = borrow_column(
2354                        &match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i + 1),
2355                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    _s
}quote! { #elem_ty },
2356                    );
2357                    borrow_pushes.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #local.push(#elem); });
2358                }
2359                borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    _s
}quote! { #elem_ty }, clone_bound.clone()));
2360            }
2361            ResolvedField::ExpandedVec(data) => {
2362                let elem_ty = &data.elem_ty;
2363                let unraw = crate::naming::unraw(&data.rust_name).to_string();
2364                let iter = match ::quote::__private::IdentFragmentAdapter(&unraw.trim_start_matches('_'))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mxv_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mxv_{}", unraw.trim_start_matches('_'));
2365                let elems = expanded_elem_idents(&unraw, data.width);
2366                borrow_pushes.push(width_elems(
2367                    &{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&field, &mut _s);
            _s
        });
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_dot2(&mut _s);
            _s
        });
    _s
}quote! { &(#field)[..] },
2368                    true,
2369                    elem_ty,
2370                    &iter,
2371                    &elems,
2372                ));
2373                for (i, elem) in elems.iter().enumerate() {
2374                    let local = borrow_column(
2375                        &match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i + 1),
2376                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::core::option::Option<#elem_ty> },
2377                    );
2378                    borrow_pushes.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #local.push(#elem); });
2379                }
2380                borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    _s
}quote! { #elem_ty }, clone_bound.clone()));
2381            }
2382            ResolvedField::AutoExpandVec(data) => {
2383                let elem_ty = &data.elem_ty;
2384                let local = borrow_column(&data.col_name, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
            _s
        });
    _s
}quote! { &[#elem_ty] });
2385                borrow_pushes.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&field, &mut _s);
                    _s
                });
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_dot2(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #local.push(&(#field)[..]); });
2386                borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    _s
}quote! { #elem_ty }, clone_bound.clone()));
2387            }
2388            ResolvedField::Struct(data) => {
2389                let inner_ty = &data.inner_ty;
2390                let local = borrow_column(&data.col_name, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    _s
}quote! { #inner_ty });
2391                borrow_pushes.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&field, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #local.push(::core::clone::Clone::clone(#field)); });
2392                borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    _s
}quote! { #inner_ty }, clone_bound.clone()));
2393            }
2394            ResolvedField::Map(data) => {
2395                let key_ty = &data.key_ty;
2396                let val_ty = &data.val_ty;
2397                let keys = borrow_column(
2398                    &match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_keys", data.base_name),
2399                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&key_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::std::vec::Vec<#key_ty> },
2400                );
2401                let vals = borrow_column(
2402                    &match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_values", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_values", data.base_name),
2403                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&val_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::std::vec::Vec<#val_ty> },
2404                );
2405                // One pass over the map, so each key stays next to its value.
2406                borrow_pushes.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unzip");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Iterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "iter");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoIterator");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_iter");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&field, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__mx_key");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__mx_val");
                            _s
                        });
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "clone");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Clone");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "clone");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__mx_key");
                                    _s
                                });
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "clone");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Clone");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "clone");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__mx_val");
                                    _s
                                });
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&keys, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&vals, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2407                    let (__mx_keys, __mx_vals) = ::core::iter::Iterator::unzip::<_, _, ::std::vec::Vec<_>, ::std::vec::Vec<_>>(
2408                        ::core::iter::Iterator::map(
2409                            ::core::iter::IntoIterator::into_iter(#field),
2410                            |(__mx_key, __mx_val)| (
2411                                ::core::clone::Clone::clone(__mx_key),
2412                                ::core::clone::Clone::clone(__mx_val),
2413                            ),
2414                        ),
2415                    );
2416                    #keys.push(__mx_keys);
2417                    #vals.push(__mx_vals);
2418                });
2419                borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&key_ty, &mut _s);
    _s
}quote! { #key_ty }, clone_bound.clone()));
2420                borrow_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&val_ty, &mut _s);
    _s
}quote! { #val_ty }, clone_bound.clone()));
2421            }
2422        }
2423    }
2424    let borrowed_column_list = column_list_body(&borrowed_local, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_len");
    _s
}quote! { __mx_len }, true);
2425    let borrow_where = conditional_where(where_clause, &borrow_bounds);
2426    let borrow_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "automatically_derived");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unused_lifetimes");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameRowBorrow");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&borrow_where, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "rows_ref_into_column_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "Self");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "List");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__mx_len");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "Self");
                            _s
                        });
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "rows");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut borrow_inits, i) = borrow_inits.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let borrow_inits =
                                match borrow_inits.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::ToTokens::to_tokens(&borrow_inits, &mut _s);
                        }
                    }
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__mx_row");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut borrow_pushes, i) =
                                    borrow_pushes.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let borrow_pushes =
                                        match borrow_pushes.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&borrow_pushes, &mut _s);
                                }
                            }
                            _s
                        });
                    ::quote::ToTokens::to_tokens(&borrowed_column_list,
                        &mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
2427        #[automatically_derived]
2428        #[allow(unused_lifetimes)]
2429        impl #impl_generics ::miniextendr_api::dataframe::DataFrameRowBorrow
2430            for #row_name #ty_generics #borrow_where
2431        {
2432            fn rows_ref_into_column_list(rows: &[Self]) -> ::miniextendr_api::List {
2433                let __mx_len = <[Self]>::len(rows);
2434                #(#borrow_inits)*
2435                for __mx_row in rows {
2436                    #(#borrow_pushes)*
2437                }
2438                #borrowed_column_list
2439            }
2440        }
2441    };
2442    // endregion
2443
2444    // region: From<Vec<RowType>>
2445    let mut col_vec_inits: Vec<TokenStream> = flat_cols
2446        .iter()
2447        .map(|fc| {
2448            let local = column_local(&fc.df_field);
2449            let ty = &fc.vec_elem_ty;
2450            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #local: ::std::vec::Vec<#ty> = ::std::vec::Vec::with_capacity(__mx_len); }
2451        })
2452        .collect();
2453    for ac in &auto_expand_cols {
2454        let local = column_local(&ac.df_field);
2455        let cty = &ac.container_ty;
2456        col_vec_inits.push(
2457            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&cty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #local: ::std::vec::Vec<#cty> = ::std::vec::Vec::with_capacity(__mx_len); },
2458        );
2459    }
2460    for sc in &struct_cols {
2461        let local = column_local(&sc.df_field);
2462        let ity = &sc.inner_ty;
2463        col_vec_inits.push(
2464            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ity, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #local: ::std::vec::Vec<#ity> = ::std::vec::Vec::with_capacity(__mx_len); },
2465        );
2466    }
2467
2468    let tag_init = if has_tag {
2469        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut __mx_col__tag: ::std::vec::Vec<::std::string::String> = ::std::vec::Vec::with_capacity(__mx_len); }
2470    } else {
2471        TokenStream::new()
2472    };
2473
2474    let tag_push = if has_tag {
2475        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&row_name_str, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { __mx_col__tag.push(#row_name_str.to_string()); }
2476    } else {
2477        TokenStream::new()
2478    };
2479
2480    // Generate push statements for each resolved field
2481    let col_pushes: Vec<TokenStream> = resolved
2482        .iter()
2483        .map(|rf| match rf {
2484            ResolvedField::Single(data) => {
2485                let access = if let Some(idx) = &data.tuple_index {
2486                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __mx_row.#idx }
2487                } else {
2488                    let rust_name = &data.rust_name;
2489                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __mx_row.#rust_name }
2490                };
2491                let col_name = column_local(&data.col_name);
2492                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #col_name.push(#access); }
2493            }
2494            ResolvedField::ExpandedFixed(data) => {
2495                let access = if let Some(idx) = &data.tuple_index {
2496                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __mx_row.#idx }
2497                } else {
2498                    let rust_name = &data.rust_name;
2499                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __mx_row.#rust_name }
2500                };
2501                let elems = expanded_elem_idents(
2502                    &crate::naming::unraw(&data.rust_name).to_string(),
2503                    data.len,
2504                );
2505                let bind = fixed_array_elems(&access, data.borrowed, &data.elem_ty, &elems);
2506                let pushes: Vec<TokenStream> = elems
2507                    .iter()
2508                    .enumerate()
2509                    .map(|(i, elem)| {
2510                        let col_ident =
2511                            column_local(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i + 1));
2512                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&col_ident, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #col_ident.push(#elem); }
2513                    })
2514                    .collect();
2515                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&bind, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut pushes, i) = pushes.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let pushes =
                match pushes.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&pushes, &mut _s);
        }
    }
    _s
}quote! {
2516                    #bind
2517                    #(#pushes)*
2518                }
2519            }
2520            ResolvedField::ExpandedVec(data) => {
2521                let access = if let Some(idx) = &data.tuple_index {
2522                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __mx_row.#idx }
2523                } else {
2524                    let rust_name = &data.rust_name;
2525                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __mx_row.#rust_name }
2526                };
2527                let iter = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.rust_name).to_string().trim_start_matches('_'))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mxv_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!(
2528                    "__mxv_{}",
2529                    crate::naming::unraw(&data.rust_name)
2530                        .to_string()
2531                        .trim_start_matches('_')
2532                );
2533                let elems = expanded_elem_idents(
2534                    &crate::naming::unraw(&data.rust_name).to_string(),
2535                    data.width,
2536                );
2537                let bind = width_elems(&access, data.borrowed, &data.elem_ty, &iter, &elems);
2538                let pushes: Vec<TokenStream> = elems
2539                    .iter()
2540                    .enumerate()
2541                    .map(|(i, elem)| {
2542                        let col_ident =
2543                            column_local(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}_{}", data.base_name, i + 1));
2544                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&col_ident, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #col_ident.push(#elem); }
2545                    })
2546                    .collect();
2547                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&bind, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut pushes, i) = pushes.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let pushes =
                match pushes.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&pushes, &mut _s);
        }
    }
    _s
}quote! {
2548                    #bind
2549                    #(#pushes)*
2550                }
2551            }
2552            ResolvedField::AutoExpandVec(data) => {
2553                let access = if let Some(idx) = &data.tuple_index {
2554                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __mx_row.#idx }
2555                } else {
2556                    let rust_name = &data.rust_name;
2557                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __mx_row.#rust_name }
2558                };
2559                let col_name = column_local(&data.col_name);
2560                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #col_name.push(#access); }
2561            }
2562            ResolvedField::Struct(data) => {
2563                let access = if let Some(idx) = &data.tuple_index {
2564                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __mx_row.#idx }
2565                } else {
2566                    let rust_name = &data.rust_name;
2567                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __mx_row.#rust_name }
2568                };
2569                let col_name = column_local(&data.col_name);
2570                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #col_name.push(#access); }
2571            }
2572            // Map (#919): unzip into parallel keys/values vecs.
2573            ResolvedField::Map(data) => {
2574                let access = if let Some(idx) = &data.tuple_index {
2575                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __mx_row.#idx }
2576                } else {
2577                    let rust_name = &data.rust_name;
2578                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __mx_row.#rust_name }
2579                };
2580                let keys_col = column_local(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_keys", data.base_name));
2581                let vals_col = column_local(&match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_values", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}_values", data.base_name));
2582                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&access, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unzip");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&keys_col, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&vals_col, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "push");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2583                    let (__mx_keys, __mx_vals) = #access
2584                        .into_iter()
2585                        .unzip::<_, _, ::std::vec::Vec<_>, ::std::vec::Vec<_>>();
2586                    #keys_col.push(__mx_keys);
2587                    #vals_col.push(__mx_vals);
2588                }
2589            }
2590        })
2591        .collect();
2592
2593    let tag_struct_field = if has_tag {
2594        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { _tag: __mx_col__tag, }
2595    } else {
2596        TokenStream::new()
2597    };
2598
2599    let len_struct_field = if flat_cols.is_empty()
2600        && auto_expand_cols.is_empty()
2601        && struct_cols.is_empty()
2602        && !has_tag
2603    {
2604        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "_len");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_len");
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { _len: __mx_len, }
2605    } else {
2606        TokenStream::new()
2607    };
2608
2609    let mut col_struct_fields: Vec<TokenStream> = flat_cols
2610        .iter()
2611        .map(|fc| {
2612            let name = &fc.df_field;
2613            let local = column_local(name);
2614            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local }
2615        })
2616        .collect();
2617    for ac in &auto_expand_cols {
2618        let name = &ac.df_field;
2619        let local = column_local(name);
2620        col_struct_fields.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local });
2621    }
2622    for sc in &struct_cols {
2623        let name = &sc.df_field;
2624        let local = column_local(name);
2625        col_struct_fields.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local });
2626    }
2627
2628    // For skipped fields in destructure: bind to `_`
2629    let skip_bindings: Vec<TokenStream> = skipped_fields
2630        .iter()
2631        .map(|(name, _)| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let _ = __mx_row.#name; })
2632        .collect();
2633
2634    let from_vec_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "convert");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "From");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__mx_len");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&tag_init, &mut _s);
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut col_vec_inits, i) =
                            col_vec_inits.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let col_vec_inits =
                                match col_vec_inits.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::ToTokens::to_tokens(&col_vec_inits, &mut _s);
                        }
                    }
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__mx_row");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&tag_push, &mut _s);
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut skip_bindings, i) =
                                    skip_bindings.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let skip_bindings =
                                        match skip_bindings.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&skip_bindings, &mut _s);
                                }
                            }
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut col_pushes, i) = col_pushes.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let col_pushes =
                                        match col_pushes.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&col_pushes, &mut _s);
                                }
                            }
                            _s
                        });
                    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&tag_struct_field, &mut _s);
                            ::quote::ToTokens::to_tokens(&len_struct_field, &mut _s);
                            ::quote::ToTokens::to_tokens(&phantom_init, &mut _s);
                            {
                                use ::quote::__private::ext::*;
                                let mut _first = true;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut col_struct_fields, i) =
                                    col_struct_fields.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let col_struct_fields =
                                        match col_struct_fields.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    if !_first { ::quote::__private::push_comma(&mut _s); }
                                    _first = false;
                                    ::quote::ToTokens::to_tokens(&col_struct_fields, &mut _s);
                                }
                            }
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
2635        impl #impl_generics ::core::convert::From<::std::vec::Vec<#row_name #ty_generics>> for #df_name #ty_generics #where_clause {
2636            fn from(rows: ::std::vec::Vec<#row_name #ty_generics>) -> Self {
2637                let __mx_len = rows.len();
2638                #tag_init
2639                #(#col_vec_inits)*
2640                for __mx_row in rows {
2641                    #tag_push
2642                    #(#skip_bindings)*
2643                    #(#col_pushes)*
2644                }
2645                #df_name {
2646                    #tag_struct_field
2647                    #len_struct_field
2648                    #phantom_init
2649                    #(#col_struct_fields),*
2650                }
2651            }
2652        }
2653    };
2654    // endregion
2655
2656    // region: Generate from_rows_par (parallel scatter-write via ColumnWriter)
2657    //
2658    // The companion's `ParallelColumns` impl moves each row to a rayon worker,
2659    // which writes the row's values into columns pre-filled with `Default`
2660    // placeholders. Two field kinds keep their values in the companion and have
2661    // no placeholder:
2662    //   - struct (DataFrameRow-flattened) fields (#485): companion stores `Vec<Inner>`.
2663    //   - `as_list`-on-struct fields (#485 opt-out): converted to a list-column
2664    //     only at frame assembly.
2665    // Both are cloned in a sequential pre-pass (`for __prerow in &rows { ... }`)
2666    // before `into_par_iter()` consumes the rows, and skipped in the parallel loop.
2667    // The pre-pass is O(n) extra per such field: a constant factor, not a change
2668    // in asymptotic complexity.
2669    //
2670    // What the fill needs of the field types (the rows `Send`, placeholder
2671    // columns `Default + Send`, pre-pass columns `Clone`) is the impl's
2672    // conditional `where` clause, so a row shape without it is not an error:
2673    // `from_rows_par` falls back to `from_rows` (`from_rows_par_override`).
2674    let has_par_impl = !flat_cols.is_empty()
2675        || !auto_expand_cols.is_empty()
2676        || has_tag
2677        || has_struct
2678        || has_into_list_struct;
2679    let (parallel_columns_item, from_rows_par_method) = if has_par_impl {
2680        let mut par_bounds: Vec<(TokenStream, TokenStream)> = ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [({
                        let mut _s = ::quote::__private::TokenStream::new();
                        ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                        ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                        _s
                    },
                    {
                        let mut _s = ::quote::__private::TokenStream::new();
                        ::quote::__private::push_colon2(&mut _s);
                        ::quote::__private::push_ident(&mut _s, "core");
                        ::quote::__private::push_colon2(&mut _s);
                        ::quote::__private::push_ident(&mut _s, "marker");
                        ::quote::__private::push_colon2(&mut _s);
                        ::quote::__private::push_ident(&mut _s, "Send");
                        _s
                    })]))vec![(
2681            quote! { #row_name #ty_generics },
2682            quote! { ::core::marker::Send },
2683        )];
2684        for fc in &flat_cols {
2685            let ty = &fc.vec_elem_ty;
2686            let bound = if fc.needs_into_list {
2687                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    _s
}quote! { ::core::clone::Clone }
2688            } else {
2689                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "default");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Default");
    ::quote::__private::push_add(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "marker");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Send");
    _s
}quote! { ::core::default::Default + ::core::marker::Send }
2690            };
2691            par_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, bound));
2692        }
2693        for ac in &auto_expand_cols {
2694            let cty = &ac.container_ty;
2695            par_bounds.push((
2696                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&cty, &mut _s);
    _s
}quote! { #cty },
2697                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "default");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Default");
    ::quote::__private::push_add(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "marker");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Send");
    _s
}quote! { ::core::default::Default + ::core::marker::Send },
2698            ));
2699        }
2700        for sc in &struct_cols {
2701            let ity = &sc.inner_ty;
2702            par_bounds.push(({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ity, &mut _s);
    _s
}quote! { #ity }, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    _s
}quote! { ::core::clone::Clone }));
2703        }
2704
2705        // Column declarations:
2706        //   - scalar / expand cols: `Default` placeholders (scatter-written in parallel)
2707        //   - struct / as_list-struct cols: filled in the pre-pass
2708        let mut par_col_decls = Vec::new();
2709        if has_tag {
2710            par_col_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "String");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2711                let mut __mx_col__tag: ::std::vec::Vec<::std::string::String> = ::std::vec![::std::string::String::new(); __mx_len];
2712            });
2713        }
2714        // Sequential pre-pass: struct fields.
2715        // Iterate resolved to pick up tuple_index for tuple-struct outers.
2716        for rf in &resolved {
2717            if let ResolvedField::Struct(data) = rf {
2718                let col_name = column_local(&data.col_name);
2719                let ity = &data.inner_ty;
2720                let access = if let Some(idx) = &data.tuple_index {
2721                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__prerow");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __prerow.#idx }
2722                } else {
2723                    let rust_name = &data.rust_name;
2724                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__prerow");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __prerow.#rust_name }
2725                };
2726                par_col_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ity, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::__private::push_ident(&mut _s, "__prerow");
    ::quote::__private::push_ident(&mut _s, "in");
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rows");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&col_name, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "push");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::ToTokens::to_tokens(&access, &mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
2727                    let mut #col_name: ::std::vec::Vec<#ity> = ::std::vec::Vec::with_capacity(__mx_len);
2728                    for __prerow in &rows {
2729                        #col_name.push(::core::clone::Clone::clone(&#access));
2730                    }
2731                });
2732            }
2733        }
2734        // Sequential pre-pass: as_list-on-struct fields. Pure Rust: the
2735        // list-column is built at frame assembly.
2736        for rf in &resolved {
2737            if let ResolvedField::Single(data) = rf
2738                && data.needs_into_list
2739            {
2740                let col_name = column_local(&data.col_name);
2741                let rust_name = &data.rust_name;
2742                let ty = &data.ty;
2743                let access = if let Some(idx) = &data.tuple_index {
2744                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__prerow");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __prerow.#idx }
2745                } else {
2746                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__prerow");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __prerow.#rust_name }
2747                };
2748                par_col_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "with_capacity");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_len");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::__private::push_ident(&mut _s, "__prerow");
    ::quote::__private::push_ident(&mut _s, "in");
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rows");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&col_name, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "push");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Clone");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "clone");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::ToTokens::to_tokens(&access, &mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
2749                    let mut #col_name: ::std::vec::Vec<#ty> = ::std::vec::Vec::with_capacity(__mx_len);
2750                    for __prerow in &rows {
2751                        #col_name.push(::core::clone::Clone::clone(&#access));
2752                    }
2753                });
2754            }
2755        }
2756        // Parallel scalar/expand columns.
2757        let placeholders = |name: &syn::Ident, ty: &syn::Type| {
2758            let local = column_local(name);
2759            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Iterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "take");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "iter");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "repeat_with");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&ty, &mut _s);
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "default");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Default");
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "default");
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__mx_len");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2760                let mut #local: ::std::vec::Vec<#ty> = ::core::iter::Iterator::collect(
2761                    ::core::iter::Iterator::take(
2762                        ::core::iter::repeat_with(<#ty as ::core::default::Default>::default),
2763                        __mx_len,
2764                    ),
2765                );
2766            }
2767        };
2768        for fc in &flat_cols {
2769            if fc.needs_into_list {
2770                // Handled in the sequential pre-pass above.
2771                continue;
2772            }
2773            par_col_decls.push(placeholders(&fc.df_field, &fc.vec_elem_ty));
2774        }
2775        for ac in &auto_expand_cols {
2776            par_col_decls.push(placeholders(&ac.df_field, &ac.container_ty));
2777        }
2778
2779        // Writer declarations (only for scatter-write cols — struct/as_list pre-pass
2780        // cols are already populated and need no ColumnWriter).
2781        let mut writer_decls = Vec::new();
2782        if has_tag {
2783            writer_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__w_tag");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon_bridge");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnWriter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2784                let __w_tag = unsafe {
2785                    ::miniextendr_api::rayon_bridge::ColumnWriter::new(&mut __mx_col__tag)
2786                };
2787            });
2788        }
2789        for fc in &flat_cols {
2790            if fc.needs_into_list {
2791                continue;
2792            }
2793            let name = &fc.df_field;
2794            let local = column_local(name);
2795            let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(name)) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(name));
2796            writer_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon_bridge");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnWriter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::ToTokens::to_tokens(&local, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2797                let #w_name = unsafe {
2798                    ::miniextendr_api::rayon_bridge::ColumnWriter::new(&mut #local)
2799                };
2800            });
2801        }
2802        for ac in &auto_expand_cols {
2803            let name = &ac.df_field;
2804            let local = column_local(name);
2805            let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(name)) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(name));
2806            writer_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon_bridge");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnWriter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::ToTokens::to_tokens(&local, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2807                let #w_name = unsafe {
2808                    ::miniextendr_api::rayon_bridge::ColumnWriter::new(&mut #local)
2809                };
2810            });
2811        }
2812
2813        // Write calls per resolved field (parallel scatter-write only).
2814        let tag_write = if has_tag {
2815            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__w_tag");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&row_name_str, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { __w_tag.write(__i, #row_name_str.to_string()); }
2816        } else {
2817            TokenStream::new()
2818        };
2819
2820        let par_write_calls: Vec<TokenStream> = resolved
2821            .iter()
2822            .map(|rf| match rf {
2823                ResolvedField::Single(data) => {
2824                    if data.needs_into_list {
2825                        // Handled in the sequential pre-pass; skip in par loop.
2826                        return TokenStream::new();
2827                    }
2828                    let access = if let Some(idx) = &data.tuple_index {
2829                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __row.#idx }
2830                    } else {
2831                        let rust_name = &data.rust_name;
2832                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __row.#rust_name }
2833                    };
2834                    let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(&data.col_name));
2835                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, #access); }
2836                }
2837                ResolvedField::ExpandedFixed(data) => {
2838                    let access = if let Some(idx) = &data.tuple_index {
2839                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __row.#idx }
2840                    } else {
2841                        let rust_name = &data.rust_name;
2842                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __row.#rust_name }
2843                    };
2844                    let elems = expanded_elem_idents(
2845                        &crate::naming::unraw(&data.rust_name).to_string(),
2846                        data.len,
2847                    );
2848                    let bind = fixed_array_elems(&access, data.borrowed, &data.elem_ty, &elems);
2849                    let writes: Vec<TokenStream> = elems
2850                        .iter()
2851                        .enumerate()
2852                        .map(|(i, elem)| {
2853                            let w_name = match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__w_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__w_{}_{}", data.base_name, i + 1);
2854                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, #elem); }
2855                        })
2856                        .collect();
2857                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&bind, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut writes, i) = writes.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let writes =
                match writes.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&writes, &mut _s);
        }
    }
    _s
}quote! {
2858                        #bind
2859                        #(#writes)*
2860                    }
2861                }
2862                ResolvedField::ExpandedVec(data) => {
2863                    let access = if let Some(idx) = &data.tuple_index {
2864                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __row.#idx }
2865                    } else {
2866                        let rust_name = &data.rust_name;
2867                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __row.#rust_name }
2868                    };
2869                    let iter = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.rust_name).to_string().trim_start_matches('_'))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mxv_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!(
2870                        "__mxv_{}",
2871                        crate::naming::unraw(&data.rust_name)
2872                            .to_string()
2873                            .trim_start_matches('_')
2874                    );
2875                    let elems = expanded_elem_idents(
2876                        &crate::naming::unraw(&data.rust_name).to_string(),
2877                        data.width,
2878                    );
2879                    let bind = width_elems(&access, data.borrowed, &data.elem_ty, &iter, &elems);
2880                    let writes: Vec<TokenStream> = elems
2881                        .iter()
2882                        .enumerate()
2883                        .map(|(i, elem)| {
2884                            let w_name = match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&(i + 1)) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__w_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__w_{}_{}", data.base_name, i + 1);
2885                            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&elem, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, #elem); }
2886                        })
2887                        .collect();
2888                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&bind, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut writes, i) = writes.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let writes =
                match writes.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&writes, &mut _s);
        }
    }
    _s
}quote! {
2889                        #bind
2890                        #(#writes)*
2891                    }
2892                }
2893                ResolvedField::AutoExpandVec(data) => {
2894                    let access = if let Some(idx) = &data.tuple_index {
2895                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __row.#idx }
2896                    } else {
2897                        let rust_name = &data.rust_name;
2898                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __row.#rust_name }
2899                    };
2900                    let w_name = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(&data.col_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}", crate::naming::unraw(&data.col_name));
2901                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&w_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&access, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { #w_name.write(__i, #access); }
2902                }
2903                // Struct fields (#485) are collected in the sequential pre-pass
2904                // above; nothing to write in the parallel loop.
2905                ResolvedField::Struct(_) => TokenStream::new(),
2906                // Map (#919): unzip into parallel keys/values vecs via scatter-write.
2907                ResolvedField::Map(data) => {
2908                    let access = if let Some(idx) = &data.tuple_index {
2909                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&idx, &mut _s);
    _s
}quote! { __row.#idx }
2910                    } else {
2911                        let rust_name = &data.rust_name;
2912                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    _s
}quote! { __row.#rust_name }
2913                    };
2914                    let w_keys = match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}_keys", data.base_name);
2915                    let w_vals = match ::quote::__private::IdentFragmentAdapter(&data.base_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__w_{0}_values", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__w_{}_values", data.base_name);
2916                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&access, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unzip");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&w_keys, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_keys");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::ToTokens::to_tokens(&w_vals, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "write");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_vals");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
2917                        let (__mx_keys, __mx_vals) = #access
2918                            .into_iter()
2919                            .unzip::<_, _, ::std::vec::Vec<_>, ::std::vec::Vec<_>>();
2920                        #w_keys.write(__i, __mx_keys);
2921                        #w_vals.write(__i, __mx_vals);
2922                    }
2923                }
2924            })
2925            .collect();
2926
2927        let par_skip_bindings: Vec<TokenStream> = skipped_fields
2928            .iter()
2929            .map(|(name, _)| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__row");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let _ = __row.#name; })
2930            .collect();
2931
2932        // Return struct fields
2933        let par_tag_field = if has_tag {
2934            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "_tag");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_col__tag");
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { _tag: __mx_col__tag, }
2935        } else {
2936            TokenStream::new()
2937        };
2938        let mut par_struct_fields: Vec<TokenStream> = flat_cols
2939            .iter()
2940            .map(|fc| {
2941                let name = &fc.df_field;
2942                let local = column_local(name);
2943                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local }
2944            })
2945            .collect();
2946        for ac in &auto_expand_cols {
2947            let name = &ac.df_field;
2948            let local = column_local(name);
2949            par_struct_fields.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local });
2950        }
2951        for sc in &struct_cols {
2952            let name = &sc.df_field;
2953            let local = column_local(name);
2954            par_struct_fields.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&local, &mut _s);
    _s
}quote! { #name: #local });
2955        }
2956
2957        // Only emit an into_par_iter call when there are scalar/expand/tag cols
2958        // to scatter-write; struct/as_list-only structs skip the parallel loop.
2959        let has_par_cols = !flat_cols.iter().all(|fc| fc.needs_into_list)
2960            || !auto_expand_cols.is_empty()
2961            || has_tag;
2962        let par_loop = if has_par_cols {
2963            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "use");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon_bridge");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rayon");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "prelude");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_star(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "optionals");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "parallel");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ensure_pool");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut writer_decls, i) = writer_decls.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let writer_decls =
                        match writer_decls.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&writer_decls, &mut _s);
                }
            }
            ::quote::__private::push_ident(&mut _s, "rows");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_par_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "enumerate");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for_each");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__i");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__row");
                            _s
                        });
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "unsafe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&tag_write, &mut _s);
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut par_write_calls, i) =
                                    par_write_calls.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let par_write_calls =
                                        match par_write_calls.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&par_write_calls, &mut _s);
                                }
                            }
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut par_skip_bindings, i) =
                                    par_skip_bindings.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let par_skip_bindings =
                                        match par_skip_bindings.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&par_skip_bindings, &mut _s);
                                }
                            }
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
2964                {
2965                    use ::miniextendr_api::rayon_bridge::rayon::prelude::*;
2966                    ::miniextendr_api::optionals::parallel::ensure_pool();
2967                    #(#writer_decls)*
2968                    rows.into_par_iter().enumerate().for_each(|(__i, __row)| unsafe {
2969                        #tag_write
2970                        #(#par_write_calls)*
2971                        #(#par_skip_bindings)*
2972                    });
2973                }
2974            }
2975        } else {
2976            // All columns were collected in the pre-pass; rows already consumed.
2977            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "_rows");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rows");
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let _rows = rows; }
2978        };
2979
2980        let parallel_columns_item = parallel_columns_impl(
2981            df_name,
2982            row_name,
2983            &input.generics,
2984            &par_bounds,
2985            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__mx_len");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rows");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut par_col_decls, i) = par_col_decls.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let par_col_decls =
                match par_col_decls.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&par_col_decls, &mut _s);
        }
    }
    ::quote::ToTokens::to_tokens(&par_loop, &mut _s);
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&par_tag_field, &mut _s);
            ::quote::ToTokens::to_tokens(&phantom_init, &mut _s);
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut par_struct_fields, i) =
                    par_struct_fields.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let par_struct_fields =
                        match par_struct_fields.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&par_struct_fields, &mut _s);
                }
            }
            _s
        });
    _s
}quote! {
2986                let __mx_len = rows.len();
2987                #(#par_col_decls)*
2988                #par_loop
2989                #df_name { #par_tag_field #phantom_init #(#par_struct_fields),* }
2990            },
2991        );
2992        (
2993            parallel_columns_item,
2994            from_rows_par_override({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    _s
}quote! { #row_name #ty_generics }),
2995        )
2996    } else {
2997        (TokenStream::new(), TokenStream::new())
2998    };
2999
3000    // region: IntoIterator (only for named non-empty structs without expansion)
3001    let can_iterate = !flat_cols.is_empty()
3002        && !is_tuple_struct
3003        && !is_unit_struct
3004        && !has_expansion
3005        && !has_into_list_struct;
3006    let into_iterator_impl = if can_iterate {
3007        let iterator_name = match ::quote::__private::IdentFragmentAdapter(&df_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}Iterator", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("{}Iterator", df_name);
3008
3009        let iter_field_decls: Vec<_> = flat_cols
3010            .iter()
3011            .map(|fc| {
3012                let name = &fc.df_field;
3013                let ty = &fc.vec_elem_ty;
3014                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoIter");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { #name: ::std::vec::IntoIter<#ty> }
3015            })
3016            .collect();
3017
3018        let destruct_pattern: Vec<_> = flat_cols
3019            .iter()
3020            .map(|fc| {
3021                let name = &fc.df_field;
3022                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    _s
}quote! { #name }
3023            })
3024            .collect();
3025
3026        let mut iter_init_tokens = TokenStream::new();
3027        for (i, fc) in flat_cols.iter().enumerate() {
3028            let name = &fc.df_field;
3029            let ty = &fc.vec_elem_ty;
3030            if i > 0 {
3031                iter_init_tokens.extend({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { , });
3032            }
3033            iter_init_tokens.extend({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&name, &mut _s);
            _s
        });
    _s
}quote! { #name: <::std::vec::Vec<#ty>>::into_iter(#name) });
3034        }
3035
3036        // For next(): reconstruct original field names (col_name == rust_name for Single)
3037        let mut next_struct_tokens = TokenStream::new();
3038        for (i, rf) in resolved.iter().enumerate() {
3039            if let ResolvedField::Single(data) = rf {
3040                if i > 0 {
3041                    next_struct_tokens.extend({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_comma(&mut _s);
    _s
}quote! { , });
3042                }
3043                let rust_name = &data.rust_name;
3044                let col_name = &data.col_name;
3045                next_struct_tokens.extend({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "next");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_question(&mut _s);
    _s
}quote! { #rust_name: self.#col_name.next()? });
3046            }
3047        }
3048
3049        // Skipped fields are reconstructed via `Default::default()` each time
3050        // `next()` yields a row, so the companion iterates rows only where every
3051        // `#[dataframe(skip)]` field type implements `Default`.
3052        let skip_defaults: Vec<TokenStream> = skipped_fields
3053            .iter()
3054            .map(|(name, _)| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_comma(&mut _s);
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "default");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Default");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "default");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { , #name: ::core::default::Default::default() })
3055            .collect();
3056        let skip_bounds: Vec<(TokenStream, TokenStream)> = skipped_fields
3057            .iter()
3058            .map(|(_, ty)| ({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty }, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "default");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Default");
    _s
}quote! { ::core::default::Default }))
3059            .collect();
3060        let iter_where = conditional_where(where_clause, &skip_bounds);
3061
3062        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&vis, &mut _s);
    ::quote::__private::push_ident(&mut _s, "struct");
    ::quote::ToTokens::to_tokens(&iterator_name, &mut _s);
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&phantom_field, &mut _s);
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut iter_field_decls, i) =
                    iter_field_decls.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let iter_field_decls =
                        match iter_field_decls.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&iter_field_decls, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unused_lifetimes");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoIterator");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&iter_where, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "type");
            ::quote::__private::push_ident(&mut _s, "Item");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "type");
            ::quote::__private::push_ident(&mut _s, "IntoIter");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&iterator_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "IntoIter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut destruct_pattern, i) =
                                    destruct_pattern.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let destruct_pattern =
                                        match destruct_pattern.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&destruct_pattern, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                }
                            }
                            ::quote::__private::push_dot2(&mut _s);
                            _s
                        });
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&iterator_name, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&phantom_init, &mut _s);
                            ::quote::ToTokens::to_tokens(&iter_init_tokens, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unused_lifetimes");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&iterator_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&iter_where, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "type");
            ::quote::__private::push_ident(&mut _s, "Item");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "next");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "self");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Item");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Some");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&next_struct_tokens, &mut _s);
                                    {
                                        use ::quote::__private::ext::*;
                                        let has_iter = ::quote::__private::HasIterator::<false>;
                                        #[allow(unused_mut)]
                                        let (mut skip_defaults, i) =
                                            skip_defaults.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let skip_defaults =
                                                match skip_defaults.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            ::quote::ToTokens::to_tokens(&skip_defaults, &mut _s);
                                        }
                                    }
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
3063            #vis struct #iterator_name #impl_generics #where_clause {
3064                #phantom_field
3065                #(#iter_field_decls),*
3066            }
3067
3068            #[allow(unused_lifetimes)]
3069            impl #impl_generics ::core::iter::IntoIterator for #df_name #ty_generics #iter_where {
3070                type Item = #row_name #ty_generics;
3071                type IntoIter = #iterator_name #ty_generics;
3072
3073                fn into_iter(self) -> Self::IntoIter {
3074                    let #df_name { #(#destruct_pattern,)* .. } = self;
3075                    #iterator_name {
3076                        #phantom_init
3077                        #iter_init_tokens
3078                    }
3079                }
3080            }
3081
3082            #[allow(unused_lifetimes)]
3083            impl #impl_generics ::core::iter::Iterator for #iterator_name #ty_generics #iter_where {
3084                type Item = #row_name #ty_generics;
3085
3086                fn next(&mut self) -> ::core::option::Option<Self::Item> {
3087                    ::core::option::Option::Some(#row_name {
3088                        #next_struct_tokens
3089                        #(#skip_defaults)*
3090                    })
3091                }
3092            }
3093        }
3094    } else {
3095        TokenStream::new()
3096    };
3097    // endregion
3098
3099    // The companion→rows path (`from_dataframe`) is not an inherent method: it is the
3100    // companion's `IntoIterator` impl, surfaced as the documented verb
3101    // `ColumnarFrame::into_rows` (available for row-iterable companions).
3102
3103    // region: from-R readers (try_from_dataframe / try_from_dataframe_par, #738/#782)
3104    //
3105    // Read an R `data.frame` SEXP directly into `Vec<Self>` without first
3106    // materialising a companion `#df_name`. A reader is generated for every
3107    // *named* struct whose fields are all reader-capable (see
3108    // `field_reader_capable`): scalar `Single` fields, column-expansion fields
3109    // (`[T; N]` / `Vec<T>` + `width`/`expand`), and struct-flatten fields (nested
3110    // `DataFrameRow`). Each shape's reader is the exact inverse of its write rule
3111    // — regroup the suffixed expansion columns, un-prefix and recurse into the
3112    // nested reader. Struct-path `HashMap<String, V>`/`BTreeMap<String, V>` map
3113    // columns read whole via `Vec<map>: TryFromSexp` (#764) — they share the
3114    // scalar `pull_col` path, gated by `SingleFieldData::map_reader` (non-String
3115    // keys / non-scalar values / custom hashers stay reader-incapable). `skip` /
3116    // `as_list` / set columns / tuple / unit shapes are not reader-capable and
3117    // fall through to the trait default (a clear runtime `DataFrameError`).
3118    // Tagged-enum and enum-`Map` readers already landed (#807/#816) — see
3119    // `enum_expansion::build_enum_reader`.
3120    //
3121    // The parallel variant (`#[cfg(feature = "rayon")]`) splits cleanly along the
3122    // R-thread boundary: all SEXP access (column extraction, ALTREP
3123    // materialisation, sub-frame selection + recursive nested reads) happens up
3124    // front on R's main thread; only then does `(0..nrow).into_par_iter()`
3125    // assemble each `Self` from the pre-extracted, owned column data by index —
3126    // pure Rust, zero R API calls. Flattened and factor fields would need
3127    // `Clone` for by-index assembly, so their `_par` reader delegates to the
3128    // sequential one (which moves) rather than imposing `Clone`.
3129    let struct_reader = !is_tuple_struct
3130        && !is_unit_struct
3131        && !has_tag
3132        && skipped_fields.is_empty()
3133        && !resolved.is_empty()
3134        && resolved.iter().all(field_reader_capable);
3135
3136    let has_autoexpand_field = resolved
3137        .iter()
3138        .any(|rf| #[allow(non_exhaustive_omitted_patterns)] match rf {
    ResolvedField::AutoExpandVec(_) => true,
    _ => false,
}matches!(rf, ResolvedField::AutoExpandVec(_)));
3139    let has_moved_reader_field = resolved.iter().any(|rf| match rf {
3140        ResolvedField::Struct(_) => true,
3141        ResolvedField::Single(data) => data.is_factor,
3142        _ => false,
3143    });
3144
3145    let reader_methods = if struct_reader {
3146        // Per-field fragments:
3147        //   extracts   — prelude statements (R-thread): pull/convert columns, run
3148        //                length checks, materialise nested sub-frames.
3149        //   seq_decls  — draining-iterator decls for the sequential row loop.
3150        //   seq_builds — `field: expr` in the sequential `Self { … }` literal
3151        //                (drains moved columns; indexes only `AutoExpandVec`).
3152        //   par_builds — `field: expr` in the parallel `Self { … }` literal
3153        //                (by-index `.clone()`; scalars only — never reached when
3154        //                a struct-flatten field is present).
3155        let mut extracts: Vec<TokenStream> = Vec::new();
3156        let mut seq_decls: Vec<TokenStream> = Vec::new();
3157        let mut seq_builds: Vec<TokenStream> = Vec::new();
3158        let mut par_builds: Vec<TokenStream> = Vec::new();
3159
3160        // Pull a named column out of R as an owned `Vec<#elem>` via `TryFromSexp`
3161        // (NA-aware, ALTREP-materialising), then length-check it against `__nrow`.
3162        // Bypasses `DataFrame::column` because its `Error = SexpError` bound is
3163        // tighter than the scalar element types' `TryFromSexp::Error`.
3164        let pull_col = |col_var: &syn::Ident,
3165                        col_name_str: &str,
3166                        elem_ty: &syn::Type,
3167                        is_factor: bool| {
3168            let convert = if is_factor {
3169                let span = syn::spanned::Spanned::span(elem_ty);
3170                {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "factor");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "FactorVec");
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "as");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "from_r");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "try_from_sexp");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "__col_sexp");
            _s
        });
    ::quote::__private::push_dot_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "map");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_or_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "values");
            ::quote::__private::push_or_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "values");
            ::quote::__private::push_dot_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "into_inner");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let _: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::TokenStream::new()
                });
            _s
        });
    _s
}quote_spanned! {span=>
3171                    <::miniextendr_api::factor::FactorVec<#elem_ty> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__col_sexp)
3172                        .map(|values| values.into_inner())
3173                }
3174            } else {
3175                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "as");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "from_r");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "TryFromSexp");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "try_from_sexp");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__col_sexp");
            _s
        });
    _s
}quote! {
3176                    <::std::vec::Vec<#elem_ty> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__col_sexp)
3177                }
3178            };
3179            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__col_sexp");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "column_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ok_or_else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"column `{}` is missing from the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::ToTokens::to_tokens(&convert, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map_err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "e");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` could not be converted to the expected type: {}\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "e");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` has length {} but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3180                let #col_var: ::std::vec::Vec<#elem_ty> = {
3181                    let __col_sexp = __view.column_raw(#col_name_str).ok_or_else(|| {
3182                        ::std::format!("column `{}` is missing from the data.frame", #col_name_str)
3183                    })?;
3184                    #convert
3185                        .map_err(|e| ::std::format!(
3186                            "column `{}` could not be converted to the expected type: {}",
3187                            #col_name_str, e
3188                        ))?
3189                };
3190                if #col_var.len() != __nrow {
3191                    return ::core::result::Result::Err(::std::format!(
3192                        "column `{}` has length {} but data.frame has {} rows",
3193                        #col_name_str, #col_var.len(), __nrow
3194                    ));
3195                }
3196            }
3197        };
3198
3199        for rf in &resolved {
3200            match rf {
3201                ResolvedField::Single(data) => {
3202                    let rust_name = &data.rust_name;
3203                    // Call-site spans: a generated local carries no span of the
3204                    // user's field, so a field named `_x` (`__col__x`) does not
3205                    // trip `non_snake_case` at the field.
3206                    let col_var = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__col_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(proc_macro2::Span::call_site())),
}format_ident!(
3207                        "__col_{}",
3208                        crate::naming::unraw(rust_name),
3209                        span = proc_macro2::Span::call_site()
3210                    );
3211                    let it_var = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__it_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(proc_macro2::Span::call_site())),
}format_ident!(
3212                        "__it_{}",
3213                        crate::naming::unraw(rust_name),
3214                        span = proc_macro2::Span::call_site()
3215                    );
3216                    match &data.list_elem_ty {
3217                        // Un-annotated owned collection: opaque list-column (VECSXP). Read
3218                        // each row's element back via `Vec<elem>: TryFromSexp`, then
3219                        // `.into()` to the field container type (`Vec<elem>` identity /
3220                        // `Box<[elem]>`). A non-list column (e.g. an all-empty column
3221                        // materialised as logical-NA) reads back as `__nrow` empty
3222                        // collections. (#809)
3223                        ::core::option::Option::Some(elem_ty) => {
3224                            let field_ty = &data.ty;
3225                            let col_name_str = &data.col_name_str;
3226                            extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&field_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__col_sexp");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "column_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ok_or_else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"column `{}` is missing from the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "if");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SexpExt");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "is_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                    _s
                });
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__list");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "unsafe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "list");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "List");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "from_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__len");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__list");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "__v");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&field_ty, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "with_capacity");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__len");
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_ident(&mut _s, "usize");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__j");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::parse(&mut _s, "0");
                    ::quote::__private::push_dot2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__elt");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__list");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "get");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__j");
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "unwrap");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__inner");
                            ::quote::__private::push_colon(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "from_r");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "TryFromSexp");
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "try_from_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__elt");
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "map_err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_or(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "e");
                                    ::quote::__private::push_or(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s,
                                                "\"column `{}` element {} could not be converted to the expected type: {}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__j");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "e");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_question(&mut _s);
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__v");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "push");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "convert");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Into");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "into");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__inner");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    ::quote::__private::push_ident(&mut _s, "__v");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "0");
                            ::quote::__private::push_dot2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "map");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_underscore(&mut _s);
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "convert");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Into");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "into");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "new");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "collect");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` has length {} but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3227                                let #col_var: ::std::vec::Vec<#field_ty> = {
3228                                    let __col_sexp = __view.column_raw(#col_name_str).ok_or_else(|| {
3229                                        ::std::format!("column `{}` is missing from the data.frame", #col_name_str)
3230                                    })?;
3231                                    // VECSXP check via `SexpExt::is_list` (UFCS — avoids the
3232                                    // `List::is_list()` bug that calls `is_pair_list()` instead).
3233                                    if <::miniextendr_api::SEXP as ::miniextendr_api::SexpExt>::is_list(&__col_sexp) {
3234                                        let __list = unsafe {
3235                                            ::miniextendr_api::list::List::from_raw(__col_sexp)
3236                                        };
3237                                        let __len = __list.len();
3238                                        let mut __v: ::std::vec::Vec<#field_ty> = ::std::vec::Vec::with_capacity(__len as usize);
3239                                        for __j in 0..__len {
3240                                            // in-bounds by construction (0..len)
3241                                            let __elt = __list.get(__j).unwrap();
3242                                            let __inner: ::std::vec::Vec<#elem_ty> =
3243                                                <::std::vec::Vec<#elem_ty> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__elt)
3244                                                    .map_err(|e| ::std::format!(
3245                                                        "column `{}` element {} could not be converted to the expected type: {}",
3246                                                        #col_name_str, __j, e
3247                                                    ))?;
3248                                            __v.push(::core::convert::Into::into(__inner));
3249                                        }
3250                                        __v
3251                                    } else {
3252                                        // Non-list column → every row is an empty collection.
3253                                        (0..__nrow)
3254                                            .map(|_| ::core::convert::Into::into(::std::vec::Vec::<#elem_ty>::new()))
3255                                            .collect()
3256                                    }
3257                                };
3258                                if #col_var.len() != __nrow {
3259                                    return ::core::result::Result::Err(::std::format!(
3260                                        "column `{}` has length {} but data.frame has {} rows",
3261                                        #col_name_str, #col_var.len(), __nrow
3262                                    ));
3263                                }
3264                            });
3265                            seq_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #it_var = #col_var.into_iter(); });
3266                            seq_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "next");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unwrap");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #rust_name: #it_var.next().unwrap() });
3267                            par_builds.push(
3268                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    _s
}quote! { #rust_name: ::core::clone::Clone::clone(&#col_var[__i]) },
3269                            );
3270                        }
3271                        // Scalar Single — and reader-capable map Single (#764):
3272                        // `pull_col`'s `Vec<#ty>: TryFromSexp` covers both
3273                        // (maps via the list-of-named-lists impl).
3274                        ::core::option::Option::None => {
3275                            extracts.push(pull_col(
3276                                &col_var,
3277                                &data.col_name_str,
3278                                &data.ty,
3279                                data.is_factor,
3280                            ));
3281                            seq_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #it_var = #col_var.into_iter(); });
3282                            seq_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "next");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unwrap");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #rust_name: #it_var.next().unwrap() });
3283                            par_builds.push(
3284                                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    _s
}quote! { #rust_name: ::core::clone::Clone::clone(&#col_var[__i]) },
3285                            );
3286                        }
3287                    }
3288                }
3289                // `[T; N]` → columns `base_1..base_N`, each a plain `Vec<elem>`.
3290                // Regroup into the fixed array per row.
3291                ResolvedField::ExpandedFixed(data) => {
3292                    let rust_name = &data.rust_name;
3293                    let elem_ty = &data.elem_ty;
3294                    let mut it_nexts: Vec<TokenStream> = Vec::new();
3295                    let mut idx_clones: Vec<TokenStream> = Vec::new();
3296                    for k in 1..=data.len {
3297                        let col_var =
3298                            match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&k) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__ef_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__ef_{}_{}", crate::naming::unraw(rust_name), k);
3299                        let it_var =
3300                            match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&k) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__efit_{0}_{1}", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__efit_{}_{}", crate::naming::unraw(rust_name), k);
3301                        let col_name_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, k))
    })format!("{}_{}", data.base_name, k);
3302                        extracts.push(pull_col(&col_var, &col_name_str, elem_ty, false));
3303                        seq_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #it_var = #col_var.into_iter(); });
3304                        it_nexts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "next");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unwrap");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #it_var.next().unwrap() });
3305                        idx_clones.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    _s
}quote! { ::core::clone::Clone::clone(&#col_var[__i]) });
3306                    }
3307                    seq_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut it_nexts, i) = it_nexts.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let it_nexts =
                        match it_nexts.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&it_nexts, &mut _s);
                }
            }
            _s
        });
    _s
}quote! { #rust_name: [ #(#it_nexts),* ] });
3308                    par_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut idx_clones, i) = idx_clones.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let idx_clones =
                        match idx_clones.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&idx_clones, &mut _s);
                }
            }
            _s
        });
    _s
}quote! { #rust_name: [ #(#idx_clones),* ] });
3309                }
3310                // `Vec<T>` + `width = N` → columns `base_1..base_N`, each
3311                // `Vec<Option<elem>>`. Flatten the N optionals per row back into a
3312                // `Vec<elem>` (trailing-NA padding from the write side drops out).
3313                ResolvedField::ExpandedVec(data) => {
3314                    let rust_name = &data.rust_name;
3315                    let elem_ty = &data.elem_ty;
3316                    let opt_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "core");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "option");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Option");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::core::option::Option<#elem_ty>);
3317                    let mut it_nexts: Vec<TokenStream> = Vec::new();
3318                    let mut idx_clones: Vec<TokenStream> = Vec::new();
3319                    for k in 1..=data.width {
3320                        let col_var =
3321                            match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&k) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__ev_{0}_{1}", arg, arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__ev_{}_{}", crate::naming::unraw(rust_name), k);
3322                        let it_var =
3323                            match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&k) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("__evit_{0}_{1}", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("__evit_{}_{}", crate::naming::unraw(rust_name), k);
3324                        let col_name_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_{1}", data.base_name, k))
    })format!("{}_{}", data.base_name, k);
3325                        extracts.push(pull_col(&col_var, &col_name_str, &opt_ty, false));
3326                        seq_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #it_var = #col_var.into_iter(); });
3327                        it_nexts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "next");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unwrap");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #it_var.next().unwrap() });
3328                        idx_clones.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    _s
}quote! { ::core::clone::Clone::clone(&#col_var[__i]) });
3329                    }
3330                    // `.into()` converts the collected `Vec<elem>` to the field's
3331                    // own container type (`Vec<T>` identity or `Box<[T]>`).
3332                    seq_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut it_nexts, i) = it_nexts.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let it_nexts =
                        match it_nexts.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&it_nexts, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "flatten");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! {
3333                        #rust_name: [ #(#it_nexts),* ]
3334                            .into_iter().flatten().collect::<::std::vec::Vec<#elem_ty>>().into()
3335                    });
3336                    par_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut idx_clones, i) = idx_clones.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let idx_clones =
                        match idx_clones.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&idx_clones, &mut _s);
                }
            }
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "flatten");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! {
3337                        #rust_name: [ #(#idx_clones),* ]
3338                            .into_iter().flatten().collect::<::std::vec::Vec<#elem_ty>>().into()
3339                    });
3340                }
3341                // `Vec<T>`/`Box<[T]>` + `expand` → a runtime-determined number of
3342                // columns `name_1..name_k`, each `Vec<Option<elem>>`. Discover them
3343                // by walking `name_<i>` until the first gap, then flatten per row.
3344                ResolvedField::AutoExpandVec(data) => {
3345                    let rust_name = &data.rust_name;
3346                    let elem_ty = &data.elem_ty;
3347                    let cols_var = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__aev_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__aev_{}", crate::naming::unraw(rust_name));
3348                    let col_name_str = &data.col_name_str;
3349                    extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&cols_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__cols");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "new");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__k");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "usize");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "1");
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "loop");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__cn");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "\"{}_{}\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name_str, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__k");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "match");
                    ::quote::__private::push_ident(&mut _s, "__view");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "column_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_and(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__cn");
                            _s
                        });
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Some");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__s");
                                    _s
                                });
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "let");
                                    ::quote::__private::push_ident(&mut _s, "__c");
                                    ::quote::__private::push_colon(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Option");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                                    ::quote::__private::push_shr(&mut _s);
                                    ::quote::__private::push_eq(&mut _s);
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "option");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Option");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                                    ::quote::__private::push_shr(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "as");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "from_r");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "TryFromSexp");
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "try_from_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__s");
                                            _s
                                        });
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "map_err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "e");
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"column `{}` could not be converted to the expected type: {}\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__cn");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "e");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_question(&mut _s);
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "if");
                                    ::quote::__private::push_ident(&mut _s, "__c");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "len");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    ::quote::__private::push_ne(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__nrow");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Brace,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "return");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "core");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "result");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Result");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Err");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "std");
                                                    ::quote::__private::push_colon2(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "format");
                                                    ::quote::__private::push_bang(&mut _s);
                                                    ::quote::__private::push_group(&mut _s,
                                                        ::quote::__private::Delimiter::Parenthesis,
                                                        {
                                                            let mut _s = ::quote::__private::TokenStream::new();
                                                            ::quote::__private::parse(&mut _s,
                                                                "\"column `{}` has length {} but data.frame has {} rows\"");
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "__cn");
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "__c");
                                                            ::quote::__private::push_dot(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "len");
                                                            ::quote::__private::push_group(&mut _s,
                                                                ::quote::__private::Delimiter::Parenthesis,
                                                                ::quote::__private::TokenStream::new());
                                                            ::quote::__private::push_comma(&mut _s);
                                                            ::quote::__private::push_ident(&mut _s, "__nrow");
                                                            _s
                                                        });
                                                    _s
                                                });
                                            ::quote::__private::push_semi(&mut _s);
                                            _s
                                        });
                                    ::quote::__private::push_ident(&mut _s, "__cols");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__c");
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__k");
                                    ::quote::__private::push_add_eq(&mut _s);
                                    ::quote::__private::parse(&mut _s, "1");
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Option");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "None");
                            ::quote::__private::push_fat_arrow(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "break");
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "__cols");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
3350                        let #cols_var: ::std::vec::Vec<::std::vec::Vec<::core::option::Option<#elem_ty>>> = {
3351                            let mut __cols: ::std::vec::Vec<::std::vec::Vec<::core::option::Option<#elem_ty>>> =
3352                                ::std::vec::Vec::new();
3353                            let mut __k: usize = 1;
3354                            loop {
3355                                let __cn = ::std::format!("{}_{}", #col_name_str, __k);
3356                                match __view.column_raw(&__cn) {
3357                                    ::core::option::Option::Some(__s) => {
3358                                        let __c: ::std::vec::Vec<::core::option::Option<#elem_ty>> =
3359                                            <::std::vec::Vec<::core::option::Option<#elem_ty>> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__s)
3360                                                .map_err(|e| ::std::format!(
3361                                                    "column `{}` could not be converted to the expected type: {}",
3362                                                    __cn, e
3363                                                ))?;
3364                                        if __c.len() != __nrow {
3365                                            return ::core::result::Result::Err(::std::format!(
3366                                                "column `{}` has length {} but data.frame has {} rows",
3367                                                __cn, __c.len(), __nrow
3368                                            ));
3369                                        }
3370                                        __cols.push(__c);
3371                                        __k += 1;
3372                                    }
3373                                    ::core::option::Option::None => break,
3374                                }
3375                            }
3376                            __cols
3377                        };
3378                    });
3379                    // Both seq and par index by row (`__i`): the columns are a
3380                    // `Vec<Vec<…>>`, so there is nothing to drain field-wise.
3381                    let build = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&cols_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "filter_map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__c");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__c");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__i");
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! {
3382                        #rust_name: #cols_var
3383                            .iter()
3384                            .filter_map(|__c| ::core::clone::Clone::clone(&__c[__i]))
3385                            .collect::<::std::vec::Vec<#elem_ty>>()
3386                            .into()
3387                    };
3388                    seq_builds.push(build.clone());
3389                    par_builds.push(build);
3390                }
3391                // Nested `DataFrameRow` (#485): the inner type's columns were
3392                // written under a `<base>_` prefix. Select those parent columns,
3393                // strip the prefix into a fresh sub-frame, and recurse through the
3394                // inner type's `DataFrameRowConvert` reader. Routing through the
3395                // trait (rather than `Inner::try_from_dataframe`) keeps this
3396                // compiling even when the inner shape has no reader — it degrades
3397                // to a clear runtime error instead.
3398                ResolvedField::Struct(data) => {
3399                    let rust_name = &data.rust_name;
3400                    let inner_ty = &data.inner_ty;
3401                    let vec_var = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__sf_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__sf_{}", crate::naming::unraw(rust_name));
3402                    let it_var = match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(rust_name))
    {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__sfit_{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__sfit_{}", crate::naming::unraw(rust_name));
3403                    let base = &data.col_name_str;
3404                    let prefix_lit = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_", data.col_name_str))
    })format!("{}_", data.col_name_str);
3405                    extracts.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&vec_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__prefix");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_ident(&mut _s, "str");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&prefix_lit, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__names");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "match");
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "names");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Ok");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__n");
                            _s
                        });
                    ::quote::__private::push_fat_arrow(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__n");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Err");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__e");
                            _s
                        });
                    ::quote::__private::push_fat_arrow(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "return");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s,
                                                "\"struct column `{}`: the data.frame\'s column names: {}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&base, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__e");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__sel");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_ident(&mut _s, "str");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__names");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "filter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__n");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__n");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "starts_with");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__prefix");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__n");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__n");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "as_str");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "collect");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "if");
            ::quote::__private::push_ident(&mut _s, "__sel");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "is_empty");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "return");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Err");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"struct column `{}`: no columns with prefix `{}` found in the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&base, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__prefix");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__sub");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "select");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__sel");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "strip_prefix");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__prefix");
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__out");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "match");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameRowConvert");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "rows_from_dataframe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__sub");
                    _s
                });
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Some");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Ok");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__v");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_fat_arrow(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__v");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Some");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__e");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_fat_arrow(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "return");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s,
                                                "\"struct column `{}`: {}\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&base, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "__e");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "None");
                    ::quote::__private::push_fat_arrow(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "return");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Result");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "format");
                                    ::quote::__private::push_bang(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s,
                                                "\"struct column `{}`: nested type has no data.frame reader\"");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&base, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__out");
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&vec_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"struct column `{}` produced {} rows but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&base, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&vec_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3406                        let #vec_var: ::std::vec::Vec<#inner_ty> = {
3407                            let __prefix: &str = #prefix_lit;
3408                            let __names = match __view.names() {
3409                                ::core::result::Result::Ok(__n) => __n,
3410                                ::core::result::Result::Err(__e) => {
3411                                    return ::core::result::Result::Err(::std::format!(
3412                                        "struct column `{}`: the data.frame's column names: {}",
3413                                        #base, __e
3414                                    ));
3415                                }
3416                            };
3417                            let __sel: ::std::vec::Vec<&str> = __names
3418                                .iter()
3419                                .filter(|__n| __n.starts_with(__prefix))
3420                                .map(|__n| __n.as_str())
3421                                .collect();
3422                            if __sel.is_empty() {
3423                                return ::core::result::Result::Err(::std::format!(
3424                                    "struct column `{}`: no columns with prefix `{}` found in the data.frame",
3425                                    #base, __prefix
3426                                ));
3427                            }
3428                            // `select` returns an owned, GC-rooted `BuiltDataFrame`
3429                            // (#1247); `strip_prefix` (inherent forward) edits the
3430                            // same frame in place and carries the handle through, so
3431                            // the sub-frame stays rooted across the CHARSXP
3432                            // allocations and the recursive read below.
3433                            let __sub = __view.select(&__sel).strip_prefix(__prefix);
3434                            let __out = match <#inner_ty as ::miniextendr_api::dataframe::DataFrameRowConvert>::rows_from_dataframe(&__sub) {
3435                                ::core::option::Option::Some(::core::result::Result::Ok(__v)) => __v,
3436                                ::core::option::Option::Some(::core::result::Result::Err(__e)) => {
3437                                    return ::core::result::Result::Err(::std::format!(
3438                                        "struct column `{}`: {}", #base, __e
3439                                    ));
3440                                }
3441                                ::core::option::Option::None => {
3442                                    return ::core::result::Result::Err(::std::format!(
3443                                        "struct column `{}`: nested type has no data.frame reader", #base
3444                                    ));
3445                                }
3446                            };
3447                            __out
3448                        };
3449                        if #vec_var.len() != __nrow {
3450                            return ::core::result::Result::Err(::std::format!(
3451                                "struct column `{}` produced {} rows but data.frame has {} rows",
3452                                #base, #vec_var.len(), __nrow
3453                            ));
3454                        }
3455                    });
3456                    seq_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&vec_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #it_var = #vec_var.into_iter(); });
3457                    seq_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&it_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "next");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unwrap");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #rust_name: #it_var.next().unwrap() });
3458                    par_builds
3459                        .push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&vec_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    _s
}quote! { #rust_name: ::core::clone::Clone::clone(&#vec_var[__i]) });
3460                }
3461                // Non-String-keyed map (#919): read two parallel list-columns
3462                // `<base>_keys` / `<base>_values` (VECSXP of typed vectors), then
3463                // zip keys[i] with values[i] back into the map type per row.
3464                // NULL VECSXP elements → empty Vec (not None — struct path uses owned cols).
3465                // All SEXP access happens in `extracts` on the R thread; the
3466                // parallel iterator touches only owned Rust `Vec<Vec<K>>` / `Vec<Vec<V>>`.
3467                ResolvedField::Map(data) => {
3468                    let rust_name = &data.rust_name;
3469                    let key_ty = &data.key_ty;
3470                    let val_ty = &data.val_ty;
3471                    let map_ty = &data.map_ty;
3472                    let base = &data.base_name;
3473                    let keys_col_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_keys", base))
    })format!("{}_keys", base);
3474                    let vals_col_name = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}_values", base))
    })format!("{}_values", base);
3475                    let keys_var = match ::quote::__private::IdentFragmentAdapter(&base.replace('-', "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_{0}_keys", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_{}_keys", base.replace('-', "_"));
3476                    let vals_var = match ::quote::__private::IdentFragmentAdapter(&base.replace('-', "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_{0}_values",
                                arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_{}_values", base.replace('-', "_"));
3477                    let keys_it_var = match ::quote::__private::IdentFragmentAdapter(&base.replace('-', "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_it_{0}_keys",
                                arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_it_{}_keys", base.replace('-', "_"));
3478                    let vals_it_var =
3479                        match ::quote::__private::IdentFragmentAdapter(&base.replace('-', "_")) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mapcol_it_{0}_values",
                                arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}format_ident!("__mapcol_it_{}_values", base.replace('-', "_"));
3480
3481                    // Extract helper: walk a VECSXP list-column; NULL/nil element → empty Vec.
3482                    let extract_col = |col_var: &syn::Ident,
3483                                       col_name: &str,
3484                                       elem_ty: &syn::Type| {
3485                        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__col_sexp");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "column_raw");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ok_or_else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "format");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"column `{}` is missing from the data.frame\"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "if");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SexpExt");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "is_list");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                    _s
                });
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__list");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "unsafe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "list");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "List");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "from_raw");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__col_sexp");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "__len");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__list");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_ident(&mut _s, "__v");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                    ::quote::__private::push_shr(&mut _s);
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "with_capacity");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__len");
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_ident(&mut _s, "usize");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "for");
                    ::quote::__private::push_ident(&mut _s, "__j");
                    ::quote::__private::push_ident(&mut _s, "in");
                    ::quote::__private::parse(&mut _s, "0");
                    ::quote::__private::push_dot2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__len");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "__elt");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__list");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "get");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__j");
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "unwrap");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "if");
                            ::quote::__private::push_ident(&mut _s, "__elt");
                            ::quote::__private::push_eq_eq(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "SEXP");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "nil");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "__v");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "vec");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "Vec");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "new");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                ::quote::__private::TokenStream::new());
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_ident(&mut _s, "else");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "let");
                                    ::quote::__private::push_ident(&mut _s, "__inner");
                                    ::quote::__private::push_colon(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_eq(&mut _s);
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "std");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "vec");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Vec");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&elem_ty, &mut _s);
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "as");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "from_r");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "TryFromSexp");
                                    ::quote::__private::push_gt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "try_from_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__elt");
                                            _s
                                        });
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "map_err");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "e");
                                            ::quote::__private::push_or(&mut _s);
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "std");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "format");
                                            ::quote::__private::push_bang(&mut _s);
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::__private::parse(&mut _s,
                                                        "\"column `{}` element {} could not be converted: {}\"");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "__j");
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::__private::push_ident(&mut _s, "e");
                                                    _s
                                                });
                                            _s
                                        });
                                    ::quote::__private::push_question(&mut _s);
                                    ::quote::__private::push_semi(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "__v");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "push");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "__inner");
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_ident(&mut _s, "__v");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "else");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "0");
                            ::quote::__private::push_dot2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "map");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_underscore(&mut _s);
                            ::quote::__private::push_or(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "new");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "collect");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "if");
    ::quote::ToTokens::to_tokens(&col_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "len");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_ne(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "return");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "format");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s,
                                "\"column `{}` has length {} but data.frame has {} rows\"");
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_name, &mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::ToTokens::to_tokens(&col_var, &mut _s);
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "len");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "__nrow");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3486                            let #col_var: ::std::vec::Vec<::std::vec::Vec<#elem_ty>> = {
3487                                let __col_sexp = __view.column_raw(#col_name).ok_or_else(|| {
3488                                    ::std::format!("column `{}` is missing from the data.frame", #col_name)
3489                                })?;
3490                                if <::miniextendr_api::SEXP as ::miniextendr_api::SexpExt>::is_list(&__col_sexp) {
3491                                    let __list = unsafe {
3492                                        ::miniextendr_api::list::List::from_raw(__col_sexp)
3493                                    };
3494                                    let __len = __list.len();
3495                                    let mut __v: ::std::vec::Vec<::std::vec::Vec<#elem_ty>> =
3496                                        ::std::vec::Vec::with_capacity(__len as usize);
3497                                    for __j in 0..__len {
3498                                        let __elt = __list.get(__j).unwrap();
3499                                        if __elt == ::miniextendr_api::SEXP::nil() {
3500                                            __v.push(::std::vec::Vec::new());
3501                                        } else {
3502                                            let __inner: ::std::vec::Vec<#elem_ty> =
3503                                                <::std::vec::Vec<#elem_ty> as ::miniextendr_api::from_r::TryFromSexp>::try_from_sexp(__elt)
3504                                                    .map_err(|e| ::std::format!(
3505                                                        "column `{}` element {} could not be converted: {}",
3506                                                        #col_name, __j, e
3507                                                    ))?;
3508                                            __v.push(__inner);
3509                                        }
3510                                    }
3511                                    __v
3512                                } else {
3513                                    // Non-list column → all rows have empty maps.
3514                                    (0..__nrow).map(|_| ::std::vec::Vec::new()).collect()
3515                                }
3516                            };
3517                            if #col_var.len() != __nrow {
3518                                return ::core::result::Result::Err(::std::format!(
3519                                    "column `{}` has length {} but data.frame has {} rows",
3520                                    #col_name, #col_var.len(), __nrow
3521                                ));
3522                            }
3523                        }
3524                    };
3525                    extracts.push(extract_col(&keys_var, &keys_col_name, key_ty));
3526                    extracts.push(extract_col(&vals_var, &vals_col_name, val_ty));
3527
3528                    seq_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&keys_it_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&keys_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #keys_it_var = #keys_var.into_iter(); });
3529                    seq_decls.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&vals_it_var, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::ToTokens::to_tokens(&vals_var, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let mut #vals_it_var = #vals_var.into_iter(); });
3530                    seq_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__k");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&keys_it_var, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "next");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "unwrap");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__v");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&vals_it_var, &mut _s);
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "next");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "unwrap");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__k");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_iter");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "zip");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__v");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "collect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&map_ty, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    _s
}quote! {
3531                        #rust_name: {
3532                            let __k = #keys_it_var.next().unwrap();
3533                            let __v = #vals_it_var.next().unwrap();
3534                            __k.into_iter().zip(__v).collect::<#map_ty>()
3535                        }
3536                    });
3537                    par_builds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rust_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Clone");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "clone");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&keys_var, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__i");
                    _s
                });
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "zip");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Clone");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "clone");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::ToTokens::to_tokens(&vals_var, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__i");
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&map_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! {
3538                        #rust_name: ::core::clone::Clone::clone(&#keys_var[__i])
3539                            .into_iter()
3540                            .zip(::core::clone::Clone::clone(&#vals_var[__i]))
3541                            .collect::<#map_ty>()
3542                    });
3543                }
3544            }
3545        }
3546
3547        // Only `AutoExpandVec` builds reference `__i` in the sequential loop; bind
3548        // the counter only then to avoid an `unused_variables` warning.
3549        let seq_counter = if has_autoexpand_field {
3550            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__i");
    _s
}quote! { __i }
3551        } else {
3552            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_underscore(&mut _s);
    _s
}quote! { _ }
3553        };
3554
3555        // Flattened and factor values need not be `Clone`. Move them through
3556        // the sequential reader, as the enum reader does for the same shapes.
3557        let par_body = if has_moved_reader_field {
3558            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "try_from_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "sexp");
            _s
        });
    _s
}quote! { Self::try_from_dataframe(sexp) }
3559        } else {
3560            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "use");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rayon_bridge");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rayon");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "prelude");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_star(&mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "optionals");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "parallel");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ensure_pool");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__view");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrame");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "from_sexp");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "sexp");
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map_err");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "e");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "e");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    ::quote::__private::push_question(&mut _s);
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__nrow");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__view");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "nrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut extracts, i) = extracts.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let extracts =
                match extracts.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&extracts, &mut _s);
        }
    }
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__rows");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::parse(&mut _s, "0");
            ::quote::__private::push_dot2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__nrow");
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_par_iter");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__i");
            ::quote::__private::push_or(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut par_builds, i) = par_builds.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let par_builds =
                                match par_builds.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&par_builds, &mut _s);
                        }
                    }
                    _s
                });
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Ok");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__rows");
            _s
        });
    _s
}quote! {
3561                use ::miniextendr_api::rayon_bridge::rayon::prelude::*;
3562                ::miniextendr_api::optionals::parallel::ensure_pool();
3563                let __view = ::miniextendr_api::dataframe::DataFrame::from_sexp(sexp)
3564                    .map_err(|e| e.to_string())?;
3565                let __nrow = __view.nrow();
3566                #(#extracts)*
3567                let __rows: ::std::vec::Vec<Self> = (0..__nrow)
3568                    .into_par_iter()
3569                    .map(|__i| Self { #(#par_builds),* })
3570                    .collect();
3571                ::core::result::Result::Ok(__rows)
3572            }
3573        };
3574
3575        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Read an R `data.frame` directly into a `Vec<Self>` (sequential).\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Each column is materialised out of R (NA-aware, ALTREP-materialising)\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" and the rows are assembled by transposing column-major into row-major.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Column-expansion fields are regrouped and nested-struct fields are\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" read from their `<field>_`-prefixed sub-frame. Returns `Err` with a\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" descriptive message if a column is missing, mis-typed, or ragged.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" This is the one-call `SEXP \u{2192} Vec<Self>` reader; the same conversion is also\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" reachable via the boundary-crossing [`FromDataFrame`] trait as\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" `Vec::<Self>::from_dataframe(&df)`.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" [`FromDataFrame`]: ::miniextendr_api::dataframe::FromDataFrame\"");
            _s
        });
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::__private::push_ident(&mut _s, "try_from_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "sexp");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_rarrow(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrame");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "sexp");
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map_err");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "e");
                    ::quote::__private::push_or(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "e");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "to_string");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_question(&mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "__nrow");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "nrow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_semi(&mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut extracts, i) = extracts.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let extracts =
                        match extracts.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&extracts, &mut _s);
                }
            }
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut seq_decls, i) = seq_decls.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let seq_decls =
                        match seq_decls.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&seq_decls, &mut _s);
                }
            }
            ::quote::__private::push_ident(&mut _s, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_ident(&mut _s, "__rows");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "with_capacity");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__nrow");
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "for");
            ::quote::ToTokens::to_tokens(&seq_counter, &mut _s);
            ::quote::__private::push_ident(&mut _s, "in");
            ::quote::__private::parse(&mut _s, "0");
            ::quote::__private::push_dot2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__nrow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__rows");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "push");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "Self");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    {
                                        use ::quote::__private::ext::*;
                                        let mut _first = true;
                                        let has_iter = ::quote::__private::HasIterator::<false>;
                                        #[allow(unused_mut)]
                                        let (mut seq_builds, i) = seq_builds.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let seq_builds =
                                                match seq_builds.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            if !_first { ::quote::__private::push_comma(&mut _s); }
                                            _first = false;
                                            ::quote::ToTokens::to_tokens(&seq_builds, &mut _s);
                                        }
                                    }
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Ok");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "__rows");
                    _s
                });
            _s
        });
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__dataframe_row_when_rayon");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Read an R `data.frame` directly into a `Vec<Self>` (parallel).\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\"\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Mirrors [`Self::try_from_dataframe`] but assembles rows off the R\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" thread via rayon. Safety: all SEXP access (column extraction, ALTREP\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" materialisation, nested sub-frame reads) happens up front on the\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" R main thread; the `into_par_iter()` region touches only\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" pre-extracted owned data and makes no R API calls.\"");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "pub");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "try_from_dataframe_par");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "sexp");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "String");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&par_body, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote! {
3576            /// Read an R `data.frame` directly into a `Vec<Self>` (sequential).
3577            ///
3578            /// Each column is materialised out of R (NA-aware, ALTREP-materialising)
3579            /// and the rows are assembled by transposing column-major into row-major.
3580            /// Column-expansion fields are regrouped and nested-struct fields are
3581            /// read from their `<field>_`-prefixed sub-frame. Returns `Err` with a
3582            /// descriptive message if a column is missing, mis-typed, or ragged.
3583            ///
3584            /// This is the one-call `SEXP → Vec<Self>` reader; the same conversion is also
3585            /// reachable via the boundary-crossing [`FromDataFrame`] trait as
3586            /// `Vec::<Self>::from_dataframe(&df)`.
3587            ///
3588            /// [`FromDataFrame`]: ::miniextendr_api::dataframe::FromDataFrame
3589            pub fn try_from_dataframe(
3590                sexp: ::miniextendr_api::SEXP,
3591            ) -> ::core::result::Result<::std::vec::Vec<Self>, ::std::string::String> {
3592                let __view = ::miniextendr_api::dataframe::DataFrame::from_sexp(sexp)
3593                    .map_err(|e| e.to_string())?;
3594                let __nrow = __view.nrow();
3595                #(#extracts)*
3596                #(#seq_decls)*
3597                let mut __rows: ::std::vec::Vec<Self> = ::std::vec::Vec::with_capacity(__nrow);
3598                for #seq_counter in 0..__nrow {
3599                    __rows.push(Self { #(#seq_builds),* });
3600                }
3601                ::core::result::Result::Ok(__rows)
3602            }
3603
3604            // api-side rayon gate — see the #1117 note on `from_rows_par` above.
3605            ::miniextendr_api::__dataframe_row_when_rayon! {
3606                /// Read an R `data.frame` directly into a `Vec<Self>` (parallel).
3607                ///
3608                /// Mirrors [`Self::try_from_dataframe`] but assembles rows off the R
3609                /// thread via rayon. Safety: all SEXP access (column extraction, ALTREP
3610                /// materialisation, nested sub-frame reads) happens up front on the
3611                /// R main thread; the `into_par_iter()` region touches only
3612                /// pre-extracted owned data and makes no R API calls.
3613                pub fn try_from_dataframe_par(
3614                    sexp: ::miniextendr_api::SEXP,
3615                ) -> ::core::result::Result<::std::vec::Vec<Self>, ::std::string::String> {
3616                    #par_body
3617                }
3618            }
3619        }
3620    } else {
3621        TokenStream::new()
3622    };
3623    // endregion
3624
3625    // region: ColumnarFrame impl on the companion (from_rows / into_rows / from_rows_par)
3626    //
3627    // The pure-Rust columnar verbs live on the `ColumnarFrame` trait, not as inherent
3628    // methods: `from_rows` (= the `From<Vec<Row>>` impl), `into_rows` (= the companion's
3629    // `IntoIterator`, for row-iterable shapes) and the `from_rows_par` override, which
3630    // picks the parallel fill where the row shape allows one.
3631    let df_methods = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ColumnarFrame");
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&df_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from_rows");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::ToTokens::to_tokens(&from_rows_par_method, &mut _s);
            _s
        });
    _s
}quote! {
3632        impl #impl_generics ::miniextendr_api::dataframe::ColumnarFrame<#row_name #ty_generics>
3633            for #df_name #ty_generics #where_clause
3634        {
3635            fn from_rows(rows: ::std::vec::Vec<#row_name #ty_generics>) -> Self {
3636                rows.into()
3637            }
3638
3639            #from_rows_par_method
3640        }
3641    };
3642
3643    // The row type carries the one-call SEXP readers (when reader-capable) plus a hidden
3644    // `to_dataframe`. The documented rows↔companion verbs live on `ColumnarFrame` / `From` /
3645    // `IntoIterator`; `to_dataframe` is retained `#[doc(hidden)]` because the struct-flatten
3646    // write path builds a nested companion via `Inner::to_dataframe(..)` without naming the
3647    // inner companion type (its name may be customised with `#[dataframe(name = ..)]`).
3648    let row_methods = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "hidden");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "pub");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "to_dataframe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_gt(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::ToTokens::to_tokens(&df_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::ToTokens::to_tokens(&reader_methods, &mut _s);
            _s
        });
    _s
}quote! {
3649        impl #impl_generics #row_name #ty_generics #where_clause {
3650            #[doc(hidden)]
3651            pub fn to_dataframe(rows: ::std::vec::Vec<Self>) -> #df_name #ty_generics {
3652                rows.into()
3653            }
3654
3655            #reader_methods
3656        }
3657    };
3658
3659    // Marker trait impl: struct type implements DataFrameRow via IntoDataFrame chain.
3660    let marker_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "markers");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameRow");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        ::quote::__private::TokenStream::new());
    _s
}quote! {
3661        impl #impl_generics ::miniextendr_api::markers::DataFrameRow
3662            for #row_name #ty_generics #where_clause {}
3663    };
3664
3665    // DataFramePayloadFields impl: exposes FIELDS (all resolved column names) and TAG
3666    // (the #[dataframe(tag = "...")] value, or "") for compile-time collision detection
3667    // by outer DataFrameRow enums that nest this type as a struct-flattened field.
3668    let payload_fields_impl = {
3669        // Collect all column names: flat_cols + struct_col base names.
3670        let mut field_names: Vec<String> =
3671            flat_cols.iter().map(|fc| fc.col_name_str.clone()).collect();
3672        for sc in &struct_cols {
3673            field_names.push(sc.col_name_str.clone());
3674        }
3675        let tag_str = attrs.tag.as_deref().unwrap_or("");
3676        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "markers");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFramePayloadFields");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_ident(&mut _s, "FIELDS");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_lifetime(&mut _s, "\'static");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_lifetime(&mut _s, "\'static");
                    ::quote::__private::push_ident(&mut _s, "str");
                    _s
                });
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut field_names, i) = field_names.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let field_names =
                                match field_names.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&field_names, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_ident(&mut _s, "TAG");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_lifetime(&mut _s, "\'static");
            ::quote::__private::push_ident(&mut _s, "str");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&tag_str, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
3677            impl #impl_generics ::miniextendr_api::markers::DataFramePayloadFields
3678                for #row_name #ty_generics #where_clause
3679            {
3680                const FIELDS: &'static [&'static str] = &[#(#field_names),*];
3681                const TAG: &'static str = #tag_str;
3682            }
3683        }
3684    };
3685
3686    // Compile-time assertions for struct-flattened fields (#485): each inner
3687    // type must implement `DataFrameRow`, otherwise users get a confusing
3688    // error pointing at the `to_dataframe` call site instead of the field.
3689    let struct_assertions: Vec<TokenStream> = struct_cols
3690        .iter()
3691        .map(|sc| {
3692            let inner_ty = &sc.inner_ty;
3693            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "const");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "_assert_inner_is_dataframe_row");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "T");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "markers");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameRow");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "_do_assert");
            ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s,
                        "_assert_inner_is_dataframe_row");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_semi(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
3694                const _: () = {
3695                    fn _assert_inner_is_dataframe_row<T: ::miniextendr_api::markers::DataFrameRow>() {}
3696                    fn _do_assert #impl_generics () #where_clause {
3697                        _assert_inner_is_dataframe_row::<#inner_ty>();
3698                    }
3699                };
3700            }
3701        })
3702        .collect();
3703    let datetime_assertions =
3704        datetime_feature_assertions(resolved.iter().filter_map(|rf| match rf {
3705            ResolvedField::Single(d) => datetime_column_ty(&d.ty),
3706            _ => None,
3707        }));
3708
3709    // region: DataFrameRowConvert on Row — orphan-rule bridge for the public verbs
3710    //
3711    // The derive cannot write `impl IntoDataFrame for Vec<Row>` directly: the orphan rule
3712    // forbids it (both `IntoDataFrame` and `Vec` are foreign in the user crate, and `Row` is
3713    // only *covered* inside `Vec<_>`). Instead it implements the local `DataFrameRowConvert`
3714    // marker on the local `Row`; miniextendr_api's blanket
3715    // `impl<T: DataFrameRowConvert> IntoDataFrame/FromDataFrame for Vec<T>` then gives users the
3716    // public verbs `rows.into_dataframe()?` / `Vec::<Row>::from_dataframe(&df)?`. The methods
3717    // delegate to the companion engine (`to_dataframe` → `ColumnSource::into_dataframe`), the
3718    // merged parallel builder (#777 `from_rows_par`) and reader (#765 `try_from_dataframe[_par]`),
3719    // converting the reader's bare `String` error into the unified `DataFrameError`.
3720
3721    // The parallel build goes through `from_rows_par` when the derive overrides it for this
3722    // shape; otherwise it is the sequential transposition.
3723    let has_par_builder = !from_rows_par_method.is_empty();
3724    let rows_into_dataframe_par_body = if has_par_builder {
3725        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "convert");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ColumnSource");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "into_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&df_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ColumnarFrame");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_rows_par");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    _s
                });
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    _s
}quote! {
3726            ::miniextendr_api::convert::ColumnSource::into_dataframe(
3727                <#df_name #ty_generics as ::miniextendr_api::dataframe::ColumnarFrame<
3728                    #row_name #ty_generics,
3729                >>::from_rows_par(rows),
3730            )
3731        }
3732    } else {
3733        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rows_into_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "rows");
            _s
        });
    _s
}quote! { Self::rows_into_dataframe(rows) }
3734    };
3735
3736    // Readers are overridden for every reader-capable struct shape (scalar,
3737    // column-expansion, struct-flatten — see `struct_reader` / `try_from_dataframe`).
3738    // Other shapes use the trait default (`None`), surfaced by the blanket as a
3739    // clear `DataFrameError`.
3740    let reader_overrides = if struct_reader {
3741        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::__private::push_ident(&mut _s, "rows_from_dataframe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "df");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrame");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_rarrow(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Result");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "vec");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Vec");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Self");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameError");
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Some");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "try_from_dataframe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "df");
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "as_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                ::quote::__private::TokenStream::new());
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "map_err");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "dataframe");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "DataFrameError");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Conversion");
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__dataframe_row_when_rayon");
    ::quote::__private::push_bang(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s,
                "rows_from_dataframe_par");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "df");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_and(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "DataFrame");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameError");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_shr(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Some");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s,
                                "try_from_dataframe_par");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "df");
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "as_sexp");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    _s
                                });
                            ::quote::__private::push_dot(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "map_err");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "dataframe");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "DataFrameError");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "Conversion");
                                    _s
                                });
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
3742            fn rows_from_dataframe(
3743                df: &::miniextendr_api::dataframe::DataFrame,
3744            ) -> ::core::option::Option<::core::result::Result<
3745                ::std::vec::Vec<Self>,
3746                ::miniextendr_api::dataframe::DataFrameError,
3747            >> {
3748                ::core::option::Option::Some(
3749                    <#row_name #ty_generics>::try_from_dataframe(df.as_sexp())
3750                        .map_err(::miniextendr_api::dataframe::DataFrameError::Conversion),
3751                )
3752            }
3753
3754            ::miniextendr_api::__dataframe_row_when_rayon! {
3755                fn rows_from_dataframe_par(
3756                    df: &::miniextendr_api::dataframe::DataFrame,
3757                ) -> ::core::option::Option<::core::result::Result<
3758                    ::std::vec::Vec<Self>,
3759                    ::miniextendr_api::dataframe::DataFrameError,
3760                >> {
3761                    ::core::option::Option::Some(
3762                        <#row_name #ty_generics>::try_from_dataframe_par(df.as_sexp())
3763                            .map_err(::miniextendr_api::dataframe::DataFrameError::Conversion),
3764                    )
3765                }
3766            }
3767        }
3768    } else {
3769        TokenStream::new()
3770    };
3771
3772    let datarow_convert_impl = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&impl_generics, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "dataframe");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "DataFrameRowConvert");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&row_name, &mut _s);
    ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "rows_into_dataframe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "rows");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vec");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Vec");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "result");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Result");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrame");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "dataframe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "DataFrameError");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "convert");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "ColumnSource");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_dataframe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&df_name, &mut _s);
                            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "convert");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "From");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::ToTokens::to_tokens(&row_name, &mut _s);
                            ::quote::ToTokens::to_tokens(&ty_generics, &mut _s);
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            ::quote::__private::push_shr(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "from");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "rows");
                                    _s
                                });
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s,
                "__dataframe_row_when_rayon");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "fn");
                    ::quote::__private::push_ident(&mut _s,
                        "rows_into_dataframe_par");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "rows");
                            ::quote::__private::push_colon(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "std");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "vec");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Vec");
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Self");
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    ::quote::__private::push_rarrow(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "result");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Result");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "DataFrame");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "dataframe");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "DataFrameError");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&rows_into_dataframe_par_body,
                                &mut _s);
                            _s
                        });
                    _s
                });
            ::quote::ToTokens::to_tokens(&reader_overrides, &mut _s);
            _s
        });
    _s
}quote! {
3773        impl #impl_generics ::miniextendr_api::dataframe::DataFrameRowConvert
3774            for #row_name #ty_generics #where_clause
3775        {
3776            fn rows_into_dataframe(
3777                rows: ::std::vec::Vec<Self>,
3778            ) -> ::core::result::Result<
3779                ::miniextendr_api::dataframe::DataFrame,
3780                ::miniextendr_api::dataframe::DataFrameError,
3781            > {
3782                ::miniextendr_api::convert::ColumnSource::into_dataframe(
3783                    <#df_name #ty_generics as ::core::convert::From<
3784                        ::std::vec::Vec<#row_name #ty_generics>,
3785                    >>::from(rows),
3786                )
3787            }
3788
3789            ::miniextendr_api::__dataframe_row_when_rayon! {
3790                fn rows_into_dataframe_par(
3791                    rows: ::std::vec::Vec<Self>,
3792                ) -> ::core::result::Result<
3793                    ::miniextendr_api::dataframe::DataFrame,
3794                    ::miniextendr_api::dataframe::DataFrameError,
3795                > {
3796                    #rows_into_dataframe_par_body
3797                }
3798            }
3799
3800            #reader_overrides
3801        }
3802    };
3803    // endregion
3804
3805    Ok({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&dataframe_struct, &mut _s);
    ::quote::ToTokens::to_tokens(&into_dataframe_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&from_vec_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&df_methods, &mut _s);
    ::quote::ToTokens::to_tokens(&parallel_columns_item, &mut _s);
    ::quote::ToTokens::to_tokens(&into_iterator_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&row_methods, &mut _s);
    ::quote::ToTokens::to_tokens(&marker_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&payload_fields_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&datarow_convert_impl, &mut _s);
    ::quote::ToTokens::to_tokens(&borrow_impl, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut struct_assertions, i) = struct_assertions.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let struct_assertions =
                match struct_assertions.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&struct_assertions, &mut _s);
        }
    }
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut datetime_assertions, i) =
            datetime_assertions.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let datetime_assertions =
                match datetime_assertions.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&datetime_assertions, &mut _s);
        }
    }
    _s
}quote! {
3806        #dataframe_struct
3807        #into_dataframe_impl
3808        #from_vec_impl
3809        #df_methods
3810        #parallel_columns_item
3811        #into_iterator_impl
3812        #row_methods
3813        #marker_impl
3814        #payload_fields_impl
3815        #datarow_convert_impl
3816        #borrow_impl
3817        #(#struct_assertions)*
3818        #(#datetime_assertions)*
3819    })
3820    // endregion
3821}
3822// endregion
3823
3824// region: Enum align path
3825
3826/// Compare column types using canonical standard-library spellings, without
3827/// changing the type emitted for the first variant. Recurse through containers
3828/// and references, but never discard arbitrary user module paths or qself.
3829///
3830/// A std path is shortened only to a prelude name (`::core::primitive::i32` →
3831/// `i32`, `std::vec::Vec` → `Vec`); a non-prelude name such as `HashMap` names
3832/// whatever the user imported. A datetime crate path ([`DATETIME_PATHS`]) drops
3833/// its leading `::` and `miniextendr_api::` prefix, so `::jiff::Timestamp`
3834/// matches `jiff::Timestamp`; a bare `Timestamp` is a nested struct field, not
3835/// a datetime column, so it never reaches this comparison as one. Parentheses and the invisible group around a
3836/// `macro_rules!` `$t:ty` are dropped. Aliases and renamed imports stay as
3837/// written, so they remain conflicts. A false match (a user `struct String`
3838/// in scope) is still caught: every merged column has one Rust type, and the
3839/// generated code moves values into and out of it without converting them, so
3840/// rustc rejects the mismatch.
3841fn same_column_type(left: &syn::Type, right: &syn::Type) -> bool {
3842    use syn::visit_mut::VisitMut;
3843
3844    struct StandardPaths;
3845    impl VisitMut for StandardPaths {
3846        fn visit_type_mut(&mut self, ty: &mut syn::Type) {
3847            loop {
3848                *ty = match ty {
3849                    syn::Type::Group(group) => (*group.elem).clone(),
3850                    syn::Type::Paren(paren) => (*paren.elem).clone(),
3851                    _ => break,
3852                };
3853            }
3854            syn::visit_mut::visit_type_mut(self, ty);
3855        }
3856
3857        fn visit_type_path_mut(&mut self, ty: &mut syn::TypePath) {
3858            syn::visit_mut::visit_type_path_mut(self, ty);
3859            if ty.qself.is_some() {
3860                return;
3861            }
3862            if let Some(path) = datetime_path(ty) {
3863                ty.path.leading_colon = None;
3864                ty.path.segments = path
3865                    .iter()
3866                    .map(|segment| syn::PathSegment::from(::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("{0}", segment))
            }), ::quote::__private::Option::None)format_ident!("{segment}")))
3867                    .collect();
3868                return;
3869            }
3870            let segments: Vec<_> = ty.path.segments.iter().collect();
3871            let [root, module, item] = segments.as_slice() else {
3872                return;
3873            };
3874            if !#[allow(non_exhaustive_omitted_patterns)] match root.arguments {
    syn::PathArguments::None => true,
    _ => false,
}matches!(root.arguments, syn::PathArguments::None)
3875                || !#[allow(non_exhaustive_omitted_patterns)] match module.arguments {
    syn::PathArguments::None => true,
    _ => false,
}matches!(module.arguments, syn::PathArguments::None)
3876            {
3877                return;
3878            }
3879            let standard = match (
3880                module.ident.to_string().as_str(),
3881                item.ident.to_string().as_str(),
3882            ) {
3883                ("primitive", _) | ("option", "Option") => {
3884                    root.ident == "core" || root.ident == "std"
3885                }
3886                ("string", "String") | ("vec", "Vec") | ("boxed", "Box") => {
3887                    root.ident == "alloc" || root.ident == "std"
3888                }
3889                _ => false,
3890            };
3891            if standard {
3892                let item = (*item).clone();
3893                ty.path.leading_colon = None;
3894                ty.path.segments = std::iter::once(item).collect();
3895            }
3896        }
3897    }
3898
3899    if left == right {
3900        return true;
3901    }
3902    let (mut left, mut right) = (left.clone(), right.clone());
3903    StandardPaths.visit_type_mut(&mut left);
3904    StandardPaths.visit_type_mut(&mut right);
3905    left == right
3906}
3907
3908/// The fix every cross-variant type-conflict error offers first: the derive
3909/// compares spellings ([`same_column_type`]), so one type needs one spelling.
3910pub(super) const SPELL_TYPES_ALIKE: &str = "If both name the same type, spell it the same way \
3911     in every variant (type aliases and renamed imports are compared as written)";
3912
3913/// A resolved column in the unified schema across all enum variants.
3914///
3915/// Tracks the column name, element type, which variants contribute to this column,
3916/// and whether the type was coerced to `String` due to cross-variant type conflicts
3917/// (when `#[dataframe(conflicts = "string")]` is active).
3918pub(super) struct ResolvedColumn {
3919    /// Column name in the companion struct / data frame.
3920    pub(super) col_name: syn::Ident,
3921    /// Element type (used as `Vec<Option<#ty>>`).
3922    /// When `string_coerced` is true, this is always `String`.
3923    pub(super) ty: syn::Type,
3924    /// Indices of variants that contain this field.
3925    pub(super) present_in: Vec<usize>,
3926    /// The variant that registered the column first (whose spelling `ty` keeps),
3927    /// named in a type-conflict error.
3928    pub(super) first_variant: syn::Ident,
3929    /// Whether this column was coerced to `String` due to type conflicts.
3930    /// When true, values are converted via `ToString::to_string()` at push time.
3931    pub(super) string_coerced: bool,
3932    /// Whether this column should be emitted as an R factor (via `as_factor` attribute).
3933    /// When `true`, `into_data_frame` wraps the `Vec<Option<T>>` in `FactorOptionVec<T>`
3934    /// before calling `IntoR::into_sexp`, using the `UnitEnumFactor` blanket impl.
3935    pub(super) is_factor: bool,
3936}
3937
3938/// Accumulates unique columns for an enum-to-dataframe unified schema.
3939///
3940/// As columns are registered from each variant's fields, the registry detects
3941/// duplicates and validates type consistency. When `coerce_to_string` is enabled,
3942/// type conflicts are resolved by coercing to `String`; otherwise they produce errors.
3943pub(super) struct ColumnRegistry<'a> {
3944    /// The ordered list of resolved columns in the schema.
3945    pub(super) columns: Vec<ResolvedColumn>,
3946    /// Maps column name strings to their index in `columns` for O(1) dedup lookup.
3947    pub(super) col_index: std::collections::HashMap<String, usize>,
3948    /// Whether to coerce type-conflicting columns to `String` instead of erroring.
3949    pub(super) coerce_to_string: bool,
3950    /// Cached `String` type AST node, used as the coercion target type.
3951    pub(super) string_ty: &'a syn::Type,
3952}
3953
3954impl<'a> ColumnRegistry<'a> {
3955    /// Create a new empty column registry.
3956    fn new(coerce_to_string: bool, string_ty: &'a syn::Type) -> Self {
3957        Self {
3958            columns: Vec::new(),
3959            col_index: std::collections::HashMap::new(),
3960            coerce_to_string,
3961            string_ty,
3962        }
3963    }
3964
3965    /// Register a single column in the schema, or merge with an existing column.
3966    ///
3967    /// If a column with the same name already exists, validates that the types match.
3968    /// On type conflict: coerces to `String` (if `coerce_to_string` is true) or
3969    /// returns `Err`. The `variant_idx` is appended to the column's `present_in` list.
3970    fn register(
3971        &mut self,
3972        col_name: &str,
3973        col_ty: &syn::Type,
3974        variant_idx: usize,
3975        variant_name: &syn::Ident,
3976        error_span: Span,
3977    ) -> syn::Result<()> {
3978        if let Some(&idx) = self.col_index.get(col_name) {
3979            let existing = &self.columns[idx];
3980            if !existing.string_coerced && !same_column_type(&existing.ty, col_ty) {
3981                if self.coerce_to_string {
3982                    self.columns[idx].ty = self.string_ty.clone();
3983                    self.columns[idx].string_coerced = true;
3984                } else {
3985                    return Err(syn::Error::new(
3986                        error_span,
3987                        ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("type conflict for field `{3}`: variant `{4}` has type `{0}`, variant `{1}` has `{2}`. {5}; otherwise use `#[dataframe(conflicts = \"string\")]` to store conflicting fields as String",
                crate::type_inspect::type_display(col_ty),
                existing.first_variant,
                crate::type_inspect::type_display(&existing.ty), col_name,
                variant_name, SPELL_TYPES_ALIKE))
    })format!(
3988                            "type conflict for field `{col_name}`: variant `{variant_name}` has \
3989                             type `{}`, variant `{}` has `{}`. {SPELL_TYPES_ALIKE}; \
3990                             otherwise use `#[dataframe(conflicts = \"string\")]` to store \
3991                             conflicting fields as String",
3992                            crate::type_inspect::type_display(col_ty),
3993                            existing.first_variant,
3994                            crate::type_inspect::type_display(&existing.ty),
3995                        ),
3996                    ));
3997                }
3998            }
3999            self.columns[idx].present_in.push(variant_idx);
4000        } else {
4001            let idx = self.columns.len();
4002            self.columns.push(ResolvedColumn {
4003                col_name: crate::naming::name_ident(col_name),
4004                ty: col_ty.clone(),
4005                present_in: ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [variant_idx]))vec![variant_idx],
4006                first_variant: variant_name.clone(),
4007                string_coerced: false,
4008                is_factor: false,
4009            });
4010            self.col_index.insert(col_name.to_string(), idx);
4011        }
4012        Ok(())
4013    }
4014
4015    /// Like `register`, but marks the column as a factor column (`is_factor = true`).
4016    ///
4017    /// Used for fields annotated with `#[dataframe(as_factor)]`. The companion struct
4018    /// field type stays `Vec<Option<T>>`, but `into_data_frame` wraps it in
4019    /// `FactorOptionVec<T>` (using the `UnitEnumFactor` blanket `IntoR` impl).
4020    pub(super) fn register_factor(
4021        &mut self,
4022        col_name: &str,
4023        col_ty: &syn::Type,
4024        variant_idx: usize,
4025        variant_name: &syn::Ident,
4026        error_span: Span,
4027    ) -> syn::Result<()> {
4028        self.register(col_name, col_ty, variant_idx, variant_name, error_span)?;
4029        if let Some(&idx) = self.col_index.get(col_name) {
4030            self.columns[idx].is_factor = true;
4031        }
4032        Ok(())
4033    }
4034}
4035
4036/// Describes the shape of an enum variant's fields.
4037#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for VariantShape {
}
#[automatically_derived]impl ::core::clone::Clone for VariantShape {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for VariantShape { }Copy, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    VariantShape {
}
#[automatically_derived]impl ::core::cmp::PartialEq for VariantShape {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for VariantShape { }Eq)]
4038pub(super) enum VariantShape {
4039    /// `Variant { field: Type, ... }`
4040    Named,
4041    /// `Variant(Type, ...)`
4042    Tuple,
4043    /// `Variant` (no fields)
4044    Unit,
4045}
4046
4047/// A resolved enum field ready for codegen -- either a single column or expanded
4048/// from an array/Vec into multiple suffixed columns.
4049///
4050/// This is the enum-path counterpart of [`ResolvedField`] (used for structs).
4051/// Each variant carries both the binding name (for destructure patterns) and the
4052/// original Rust field name (for error reporting and named-variant patterns).
4053pub(super) enum EnumResolvedField {
4054    /// Single column contribution.
4055    Single(Box<EnumSingleFieldData>),
4056    /// Expanded from [T; N].
4057    ExpandedFixed(Box<EnumExpandedFixedData>),
4058    /// Expanded from `Vec<T>` with pinned width.
4059    ExpandedVec(Box<EnumExpandedVecData>),
4060    /// Auto-expanded `Vec<T>`/`Box<[T]>`: column count determined at runtime.
4061    AutoExpandVec(Box<EnumAutoExpandVecData>),
4062    /// `HashMap<K,V>` or `BTreeMap<K,V>` → two parallel list-columns: `<field>_keys`, `<field>_values`.
4063    Map(Box<EnumMapFieldData>),
4064    /// Struct field whose inner type implements `DataFrameRow` → flattened `<base>_<inner_col>` columns.
4065    Struct(Box<EnumStructFieldData>),
4066}
4067
4068impl EnumResolvedField {
4069    /// Binding name used in destructure patterns.
4070    pub(super) fn binding(&self) -> &syn::Ident {
4071        match self {
4072            Self::Single(data) => &data.binding,
4073            Self::ExpandedFixed(data) => &data.binding,
4074            Self::ExpandedVec(data) => &data.binding,
4075            Self::AutoExpandVec(data) => &data.binding,
4076            Self::Map(data) => &data.binding,
4077            Self::Struct(data) => &data.binding,
4078        }
4079    }
4080
4081    /// Original Rust field name.
4082    pub(super) fn rust_name(&self) -> &syn::Ident {
4083        match self {
4084            Self::Single(data) => &data.rust_name,
4085            Self::ExpandedFixed(data) => &data.rust_name,
4086            Self::ExpandedVec(data) => &data.rust_name,
4087            Self::AutoExpandVec(data) => &data.rust_name,
4088            Self::Map(data) => &data.rust_name,
4089            Self::Struct(data) => &data.rust_name,
4090        }
4091    }
4092}
4093
4094/// Data for [`EnumResolvedField::Single`].
4095pub(super) struct EnumSingleFieldData {
4096    /// Column name in the schema.
4097    pub(super) col_name: syn::Ident,
4098    /// Binding name used in destructure pattern.
4099    pub(super) binding: syn::Ident,
4100    /// Original Rust field name (for named variants).
4101    pub(super) rust_name: syn::Ident,
4102    /// Column type stored in the companion Vec: the field's Rust type, also
4103    /// when `needs_into_list` is set (the companion holds no R objects).
4104    pub(super) ty: syn::Type,
4105    /// Whether the column is built by converting each value via `.into_list()`
4106    /// when the frame is assembled (`into_option_list_column` /
4107    /// `into_list_column`), rather than through `IntoR` for the whole `Vec`.
4108    ///
4109    /// Set to `true` only for struct-typed fields (`FieldTypeKind::Struct`)
4110    /// that carry `#[dataframe(as_list)]`.
4111    pub(super) needs_into_list: bool,
4112    /// Whether the field should be emitted as an R factor column.
4113    ///
4114    /// Set to `true` for fields annotated with `#[dataframe(as_factor)]`.
4115    /// The companion struct field type is `Vec<Option<T>>` (unchanged), but
4116    /// `into_data_frame` wraps it in `FactorOptionVec<T>` to use the
4117    /// `UnitEnumFactor`-based blanket `IntoR` impl.
4118    pub(super) is_factor: bool,
4119}
4120
4121/// Data for [`EnumResolvedField::ExpandedFixed`].
4122pub(super) struct EnumExpandedFixedData {
4123    /// Base column name.
4124    pub(super) base_name: String,
4125    /// Binding name.
4126    pub(super) binding: syn::Ident,
4127    /// Original Rust field name.
4128    pub(super) rust_name: syn::Ident,
4129    /// Element type.
4130    pub(super) elem_ty: syn::Type,
4131    /// Array length.
4132    pub(super) len: usize,
4133    /// The field is `&[T; N]`: its elements are cloned out, not moved.
4134    pub(super) borrowed: bool,
4135}
4136
4137/// Data for [`EnumResolvedField::ExpandedVec`].
4138pub(super) struct EnumExpandedVecData {
4139    /// Base column name.
4140    pub(super) base_name: String,
4141    /// Binding name.
4142    pub(super) binding: syn::Ident,
4143    /// Original Rust field name.
4144    pub(super) rust_name: syn::Ident,
4145    /// Element type.
4146    pub(super) elem_ty: syn::Type,
4147    /// Pinned width.
4148    pub(super) width: usize,
4149    /// The field is `&[T]`: its elements are cloned out, not moved.
4150    pub(super) borrowed: bool,
4151}
4152
4153/// Data for [`EnumResolvedField::AutoExpandVec`].
4154pub(super) struct EnumAutoExpandVecData {
4155    /// Base column name.
4156    pub(super) base_name: String,
4157    /// Binding name.
4158    pub(super) binding: syn::Ident,
4159    /// Original Rust field name.
4160    pub(super) rust_name: syn::Ident,
4161    /// Element type.
4162    pub(super) elem_ty: syn::Type,
4163    /// Container type for companion struct (`Vec<T>` or `Box<[T]>`).
4164    pub(super) container_ty: syn::Type,
4165    /// The field is `&[T]`: its elements are cloned out, not moved.
4166    pub(super) borrowed: bool,
4167}
4168
4169/// Data for [`EnumResolvedField::Map`].
4170///
4171/// A `HashMap<K,V>` or `BTreeMap<K,V>` field expands to two parallel list-columns:
4172/// `<base_name>_keys: Vec<Option<Vec<K>>>` and `<base_name>_values: Vec<Option<Vec<V>>>`.
4173/// Absent-variant rows get `None` in both columns. Key order follows the map's own
4174/// iteration order: `BTreeMap` yields sorted keys, `HashMap` yields non-deterministic order.
4175/// Both are produced via `into_iter().unzip()` which guarantees pairwise alignment.
4176pub(super) struct EnumMapFieldData {
4177    /// Base column name (field name or `rename` override).
4178    pub(super) base_name: String,
4179    /// Binding name used in destructure pattern.
4180    pub(super) binding: syn::Ident,
4181    /// Original Rust field name.
4182    pub(super) rust_name: syn::Ident,
4183    /// Key type K.
4184    pub(super) key_ty: syn::Type,
4185    /// Value type V.
4186    pub(super) val_ty: syn::Type,
4187    /// Full original field type (`HashMap<K, V>` / `BTreeMap<K, V>`). The reader
4188    /// regroups the `_keys`/`_values` list-columns and `collect()`s back into this
4189    /// exact map type — both `HashMap` and `BTreeMap` implement `FromIterator<(K, V)>`.
4190    pub(super) map_ty: syn::Type,
4191}
4192
4193/// Data for [`EnumResolvedField::Struct`].
4194///
4195/// A field whose inner type implements `DataFrameRow` expands to `<base_name>_<inner_col>`
4196/// prefixed columns — one output column per column emitted by the inner type's companion
4197/// DataFrame. Absent-variant rows produce `None` in every prefixed column.
4198///
4199/// The companion struct holds `Vec<Option<Inner>>` (not `Vec<Inner>`). The `into_data_frame`
4200/// method collects present rows into a dense `Vec<Inner>` (tracking presence indices),
4201/// calls `Inner::to_dataframe(present_rows)`, extracts named column SEXPs, and scatters
4202/// them back to the full row count with `None`-fill for absent rows.
4203pub(super) struct EnumStructFieldData {
4204    /// Base name for column prefixing (field name or `rename` override).
4205    pub(super) base_name: String,
4206    /// Binding name used in destructure pattern.
4207    pub(super) binding: syn::Ident,
4208    /// Original Rust field name.
4209    pub(super) rust_name: syn::Ident,
4210    /// Inner struct type (used for the compile-time DataFrameRow assertion and codegen).
4211    pub(super) inner_ty: syn::Type,
4212}
4213
4214/// Parsed and resolved information about a single enum variant for DataFrame codegen.
4215///
4216/// Contains the variant's name, shape (named/tuple/unit), resolved fields (after
4217/// applying `#[dataframe(...)]` attributes and type classification), and any
4218/// skipped field names (needed for complete destructure patterns in named variants).
4219pub(super) struct VariantInfo {
4220    /// Variant name.
4221    pub(super) name: syn::Ident,
4222    /// Shape of this variant.
4223    pub(super) shape: VariantShape,
4224    /// Resolved fields (after applying field attrs + type classification).
4225    pub(super) fields: Vec<EnumResolvedField>,
4226    /// Original Rust field names (for named variants) — needed for skipped fields in destructure.
4227    pub(super) skipped_fields: Vec<syn::Ident>,
4228}
4229// endregion
4230
4231// region: Enum-specific expansion (in sub-module)
4232
4233mod enum_expansion;
4234use enum_expansion::derive_enum_dataframe;
4235// endregion
4236
4237// region: tests
4238#[cfg(test)]
4239mod tests;
4240// endregion