SEQUENCE

1 sequence_fn "SEQUENCE" (1, 4) [V "rows", V "columns", V "start", V "step"] resume sequence_resume => sequence_task; |s, a, sv| {
    result(s, k::eval_sequence_prepared(a))
}

fn sequence_task(
    site: &Site<'_>,
    args: &[CalcValue],
    _: &mut EvalServices<'_>,
) -> Step<Box<dyn crate::call::KernelTask>> {
    Ok(Box::new(SequenceTask(result(
        site,
        k::SequenceWork::new(args),
    )?)))
}

fn new(arg: &'a CalcValue) -> Self {
    match arg.core_ref() {
        CoreRef::Array(array) => Self::Array(array),
        _ => Self::Scalar(scalar_cell(arg)),
    }
}

pub(crate) fn new(args: &[CalcValue]) -> Result<Self, DynamicArrayReshapeEvalError> {
    // Fn2 roots164/165: formed argument errors keep their order before a
    // dimension-derived error. Arrays and callable values keep their own route.
    for value in args {
        if value.callable_value().is_none()
            && let CoreRef::Error(code) = value.core_ref()
        {
            return Err(DynamicArrayReshapeEvalError::Preparation(
                CoercionError::WorksheetError(code),
            ));
        }
    }
    fn dimension(arg: Option<&CalcValue>) -> Result<usize, DynamicArrayReshapeEvalError> {
        let raw = match arg {
            None => return Ok(1),
            Some(value) if matches!(value.core_ref(), CoreRef::Missing | CoreRef::Empty) => {
                return Ok(1);
            }
            Some(value) => coerce_prepared_to_number(value)
                .map_err(DynamicArrayReshapeEvalError::Preparation)?,
        };
        if raw == 0.0 {
            return Err(DynamicArrayReshapeEvalError::EmptyArrayResult);
        }
        if !raw.is_finite() || raw < 0.0 || raw.fract() != 0.0 {
            return Err(DynamicArrayReshapeEvalError::InvalidCount);
        }
        Ok(raw as usize)
    }
    fn scalar(arg: Option<&CalcValue>) -> Result<f64, DynamicArrayReshapeEvalError> {
        match arg {
            None => Ok(1.0),
            Some(value) if matches!(value.core_ref(), CoreRef::Missing | CoreRef::Empty) => {
                Ok(1.0)
            }
            Some(value) => coerce_prepared_to_number(value)
                .map_err(DynamicArrayReshapeEvalError::Preparation),
        }
    }
    let rows = dimension(args.first())?;
    let cols = dimension(args.get(1))?;
    let start = scalar(args.get(2))?;
    let step = scalar(args.get(3))?;
    let count = ArrayShape { rows, cols }
        .cell_count()
        .ok_or(DynamicArrayReshapeEvalError::InvalidCount)?;
    Ok(Self {
        rows,
        cols,
        start,
        step,
        count,
        cells: Vec::new(),
    })
}

pub(crate) fn advance(
    &mut self,
    elements: usize,
) -> Option<Result<CalcValue, DynamicArrayReshapeEvalError>> {
    let end = self.cells.len().saturating_add(elements).min(self.count);
    for idx in self.cells.len()..end {
        self.cells
            .push(CalcValue::number(self.start + (idx as f64) * self.step));
    }
    (end == self.count)
        .then(|| build_array(self.rows, self.cols, std::mem::take(&mut self.cells)))
}

pub fn eval_sequence_prepared(
    args: &[CalcValue],
) -> Result<CalcValue, DynamicArrayReshapeEvalError> {
    SequenceWork::new(args)?
        .advance(usize::MAX)
        .expect("unlimited sequence completes")
}