//! A time-series abstraction. A date of with granularity in months or larger associated with a
//! numeric array of any size. 
///

/// A duration between two `MonthlyDates`.

/// A duration between two `Months`.

impl fmt::Display for Duration {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = String::new();
        match self.0 {
            1 => s.push_str("1 month"),
            n => {
                s.push_str(&n.to_string());
                s.push_str(" months");
            },
        };
        write!(f, "{}", s)
    }
}

            let year = match line[..4].parse() {
                Ok(y) => y,
                Err(_) => {
                    return Err(parse_csv_date_failed(

            let year = line[..4].parse()
                .map_err(|_| {
                    parse_csv_date_failed(

                    ))
                },
            };

                    )
                })?;

            let month = match line[5..7].parse() {
                Ok(m) => m,
                Err(_) => {
                    return Err(parse_csv_date_failed(

            let month = line[5..7].parse()
                .map_err(|_| {
                    parse_csv_date_failed(

                    ))
                },
            };

                    )
                })?;

            let value = match line[12..].parse::<f32>() {
                Ok(value) => value,
                Err(_) => {
                    return Err(parse_csv_value_failed(

            let value = line[12..].parse::<f32>()
                .map_err(|_| {
                    parse_csv_value_failed(

                    ))
                },
            };

                    )
                })?;

    // /// Return true if the durations between Points are all equal.
    // pub fn is_regular(&self, duration: &MonthlyDate) -> bool {
    //     if self.len < 2 {
    //         return false
    //     } else {
    //         self.0.as_slice().windows(2).all(|datapoint_pair| {
    //             datapoint_pair[1].date() - datapoint_pair[0].date() == *duration
    //         })
    //     }
    // }

    pub fn zip_one_one(self, other: RegularTimeSeries<1>) -> RegularTimeSeries<2> {

    pub fn zip_one_one(self, other: RegularTimeSeries<1>) -> Result<RegularTimeSeries<2>, Error> {

        if self.duration() != other.duration() { panic!() };

        if self.duration() != other.duration() {
            return Err(expected_same_durations(
                file!(),
                line!(),
                &self.duration().to_string(),
                &other.duration().to_string(),
            ));
        };

        TimeSeries::<2>::new(v).try_into().unwrap()

        TimeSeries::<2>::new(v).try_into()

        let index = (date.as_isize() - self.first_date().as_isize()) / self.duration.0;

        let index = date.as_isize() - self.first_date().as_isize() / self.duration.0;

///

pub fn expected_same_durations(
    code_file: &str,
    code_line: u32,
    first_duration: &str,
    second_duration: &str) -> Error
{
    Error(format!(
        "[time_series:02:{}:{}] Expected time-series to have same duration but had [{}] and [{}].",
        code_file,
        code_line,
        first_duration,
        second_duration,
    ))
}