Struct ListAccumulator 

pub struct ListAccumulator<'a> {
    list: ReprotectSlot<'a>,
    temp: ReprotectSlot<'a>,
    len: usize,
    cap: usize,
    scope: &'a ProtectScope,
    names: Vec<Option<String>>,
}

Accumulator for building lists when the length is unknown upfront.

Unlike super::ListBuilder which requires knowing the size at construction, ListAccumulator supports dynamic growth via push. It uses ReprotectSlot internally to maintain O(1) protect stack usage regardless of how many elements are pushed.

When to Use

Scenario	Recommended Type
Known size	super::ListBuilder - more efficient, no reallocation
Unknown size	ListAccumulator - bounded stack, dynamic growth
Streaming/iterators	ListAccumulator or collect_list

Growth Strategy

The internal list grows exponentially (2x) when capacity is exceeded, achieving amortized O(1) push. Elements are copied during growth.

Example

unsafe fn collect_filtered(items: &[i32]) -> SEXP {
    let scope = ProtectScope::new();
    let mut acc = ListAccumulator::new(&scope, 4); // initial capacity hint

    for &item in items {
        if item > 0 {
            acc.push(item);  // auto-converts via IntoR
        }
    }

    acc.into_root().get()
}

Fields

list: ReprotectSlot<'a>

The current list container (protected via ReprotectSlot).

temp: ReprotectSlot<'a>

Temporary slot for element conversion and list growth.

len: usize

Number of elements currently in the list.

cap: usize

Current capacity of the list.

scope: &'a ProtectScope

Reference to the scope for creating the final Root.

names: Vec<Option<String>>

Per-element names (None = unnamed, Some = named).

Implementations

impl<'a> ListAccumulator<'a>

pub unsafe fn new(scope: &'a ProtectScope, initial_cap: usize) -> Self

Create a new accumulator with the given initial capacity.

A capacity of 0 is valid; the list will grow on first push.

Safety

Must be called from the R main thread.

pub unsafe fn push<T: IntoR>(&mut self, value: T)

Push a value onto the accumulator.

The value is converted to a SEXP via IntoR and inserted. If the internal list is full, it grows automatically.

Safety

Must be called from the R main thread.

pub unsafe fn push_sexp(&mut self, sexp: SEXP)

Push a raw SEXP onto the accumulator.

Safety

• Must be called from the R main thread
• sexp must be a valid SEXP (it will be temporarily protected)

pub unsafe fn push_named<T: IntoR>(&mut self, name: &str, value: T)

Push a named value onto the accumulator.

Safety

Must be called from the R main thread.

pub unsafe fn push_if<T: IntoR>(&mut self, condition: bool, value: T)

Push a value only if the condition is true.

Safety

Must be called from the R main thread.

pub unsafe fn push_if_with<T: IntoR>( &mut self, condition: bool, f: impl FnOnce() -> T, )

Push a lazily-evaluated value only if the condition is true.

The closure is only called if condition is true.

Safety

Must be called from the R main thread.

pub unsafe fn extend_from<I, T>(&mut self, iter: I)

where I: IntoIterator<Item = T>, T: IntoR,

Push all items from an iterator.

Safety

Must be called from the R main thread.

unsafe fn grow(&mut self)

Grow the internal list by 2x.

Safety

Must be called from the R main thread.

pub fn len(&self) -> usize

Get the current number of elements.

pub fn is_empty(&self) -> bool

Check if the accumulator is empty.

pub fn capacity(&self) -> usize

Get the current capacity.

pub unsafe fn into_root(self) -> Root<'a>

Finalize the accumulator and return a Root pointing to the list.

The returned list is truncated to the actual length (if smaller than capacity).

Safety

Must be called from the R main thread.

pub unsafe fn into_sexp(self) -> SEXP

Finalize and return the raw SEXP.

Safety

Must be called from the R main thread.