Method next

compiler/src/modules/vm/builtins/sequence.rs:25–55

Next value; allocates only for StrChars. Err on alloc failure, Ok(None) on exhaustion.

(&mut self, heap: &mut HeapPool)

impl IterCursor {
    // Next value; allocates only for StrChars. Err on alloc failure, Ok(None) on exhaustion.
    pub fn next(&mut self, heap: &mut HeapPool) -> Result<Option<Val>, VmErr> {
        match self {
            Self::Range { cur, end, step } => {
                let (c, e, s) = (*cur, *end, *step);
                let live = if s > 0 { c < e } else if s < 0 { c > e } else { false };
                if !live { return Ok(None); }
                // Clamp past the i64 edge so the next call ends the range, never overflows.
                *cur = c.checked_add(s).unwrap_or(if s > 0 { i64::MAX } else { i64::MIN });
                Ok(Some(range_int(heap, c)?))
            }
            Self::Vec { items, idx } => {
                if *idx >= items.len() { return Ok(None); }
                let v = items[*idx];
                *idx += 1;
                Ok(Some(v))
            }
            Self::Bytes { bytes, idx } => {
                if *idx >= bytes.len() { return Ok(None); }
                let b = bytes[*idx];
                *idx += 1;
                Ok(Some(Val::int(b as i64)))
            }
            Self::StrChars { chars, idx } => {
                if *idx >= chars.len() { return Ok(None); }
                let mut s = alloc::string::String::new();
                s.push(chars[*idx]);
                *idx += 1;
                Ok(Some(heap.alloc(HeapObj::Str(s))?))
            }
        }
    }
}

impl<'a> VM<'a> {