Method plot_nested

src/lib.rs:285–369

(
        &self,
        call: &EvaluatedCall,
        input: &Value,
    )

    }

    fn plot_nested<'a>(
        &self,
        call: &EvaluatedCall,
        input: &Value,
    ) -> Result<Value, LabeledError> {
        let CliOpts {
            height_op,
            width_op,
            legend,
            steps,
            bars,
            points,
            title,
            bins: _,
        } = parse_cli_opts(call)?;

        let max_x = width_op.unwrap_or(200);
        let max_y = height_op.unwrap_or(50);

        let values = input.as_list()?;
        if values.len() > 5 {
            return Err(LabeledError::new("Nested list can't contain more than 5 inner lists.").with_label("Nested list error.", call.head));
        }

        let mut data = vec![];

        for val in values {
            let list = val.as_list()?;

            let v: Result<Vec<(f32, f32)>, LabeledError> = list
                .iter()
                .enumerate()
                .map(|(i, e)| match e {
                    Value::Int { .. } => Ok((i as f32, e.as_int()? as f32)),
                    Value::Float { .. } => Ok((i as f32, e.as_float()? as f32)),
                    e => Err(LabeledError::new(format!("Got {}, need integer or float.", e.get_type())).with_label("Incorrect type supplied.", call.head)),
                })
                .collect();

            let min_max_x = {
                let x: Vec<f32> = v.clone()?.iter().map(|e| e.0).collect();
                let y: Option<Vec<f32>> = None;
                (min_max(&x), y)
            };

            data.push((min_max_x, v?));
        }

        let min_all: Vec<f32> = data.iter().map(|((e, _), _)| e.0).collect();
        let max_all: Vec<f32> = data.iter().map(|((e, _), _)| e.1).collect();

        let min = min_all.iter().fold(f32::INFINITY, |a, &b| a.min(b));
        let max = *max_all.iter().max_by(|a, b| a.total_cmp(b)).unwrap();

        // copying data structure again here but wanted to be explicit.
        let chart_data: Vec<Vec<(f32, f32)>> = data.iter().map(|(_, e)| e.clone()).collect();

        // let shapes = chart_data.into_iter().map(|data| chart_shape(steps, bars, points, call, &data));