Merging upstream version 1.68.2+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 0 insertions, 840 deletions

diff --git a/src/test/ui/impl-trait/example-calendar.rs b/src/test/ui/impl-trait/example-calendar.rs
deleted file mode 100644
index da45f0d13..000000000
--- a/src/test/ui/impl-trait/example-calendar.rs
+++ /dev/null
@@ -1,840 +0,0 @@
-// run-pass
-
-#![feature(fn_traits,
-           step_trait,
-           unboxed_closures,
-)]
-
-//! Derived from: <https://raw.githubusercontent.com/quickfur/dcal/master/dcal.d>.
-//!
-//! Originally converted to Rust by [Daniel Keep](https://github.com/DanielKeep).
-
-use std::fmt::Write;
-
-/// Date representation.
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-struct NaiveDate(i32, u32, u32);
-
-impl NaiveDate {
-    pub fn from_ymd(y: i32, m: u32, d: u32) -> NaiveDate {
-        assert!(1 <= m && m <= 12, "m = {:?}", m);
-        assert!(1 <= d && d <= NaiveDate(y, m, 1).days_in_month(), "d = {:?}", d);
-        NaiveDate(y, m, d)
-    }
-
-    pub fn year(&self) -> i32 {
-        self.0
-    }
-
-    pub fn month(&self) -> u32 {
-        self.1
-    }
-
-    pub fn day(&self) -> u32 {
-        self.2
-    }
-
-    pub fn succ(&self) -> NaiveDate {
-        let (mut y, mut m, mut d, n) = (
-            self.year(), self.month(), self.day()+1, self.days_in_month());
-        if d > n {
-            d = 1;
-            m += 1;
-        }
-        if m > 12 {
-            m = 1;
-            y += 1;
-        }
-        NaiveDate::from_ymd(y, m, d)
-    }
-
-    pub fn weekday(&self) -> Weekday {
-        use Weekday::*;
-
-        // 0 = Sunday
-        let year = self.year();
-        let dow_jan_1 = (year*365 + ((year-1) / 4) - ((year-1) / 100) + ((year-1) / 400)) % 7;
-        let dow = (dow_jan_1 + (self.day_of_year() as i32 - 1)) % 7;
-        [Sun, Mon, Tue, Wed, Thu, Fri, Sat][dow as usize]
-    }
-
-    pub fn isoweekdate(&self) -> (i32, u32, Weekday) {
-        let first_dow_mon_0 = self.year_first_day_of_week().num_days_from_monday();
-
-        // Work out this date's DOtY and week number, not including year adjustment.
-        let doy_0 = self.day_of_year() - 1;
-        let mut week_mon_0: i32 = ((first_dow_mon_0 + doy_0) / 7) as i32;
-
-        if self.first_week_in_prev_year() {
-            week_mon_0 -= 1;
-        }
-
-        let weeks_in_year = self.last_week_number();
-
-        // Work out the final result.
-        // If the week is `-1` or `>= weeks_in_year`, we will need to adjust the year.
-        let year = self.year();
-        let wd = self.weekday();
-
-        if week_mon_0 < 0 {
-            (year - 1, NaiveDate::from_ymd(year - 1, 1, 1).last_week_number(), wd)
-        } else if week_mon_0 >= weeks_in_year as i32 {
-            (year + 1, (week_mon_0 + 1 - weeks_in_year as i32) as u32, wd)
-        } else {
-            (year, (week_mon_0 + 1) as u32, wd)
-        }
-    }
-
-    fn first_week_in_prev_year(&self) -> bool {
-        let first_dow_mon_0 = self.year_first_day_of_week().num_days_from_monday();
-
-        // Any day in the year *before* the first Monday of that year
-        // is considered to be in the last week of the previous year,
-        // assuming the first week has *less* than four days in it.
-        // Adjust the week appropriately.
-        ((7 - first_dow_mon_0) % 7) < 4
-    }
-
-    fn year_first_day_of_week(&self) -> Weekday {
-        NaiveDate::from_ymd(self.year(), 1, 1).weekday()
-    }
-
-    fn weeks_in_year(&self) -> u32 {
-        let days_in_last_week = self.year_first_day_of_week().num_days_from_monday() + 1;
-        if days_in_last_week >= 4 { 53 } else { 52 }
-    }
-
-    fn last_week_number(&self) -> u32 {
-        let wiy = self.weeks_in_year();
-        if self.first_week_in_prev_year() { wiy - 1 } else { wiy }
-    }
-
-    fn day_of_year(&self) -> u32 {
-        (1..self.1).map(|m| NaiveDate::from_ymd(self.year(), m, 1).days_in_month())
-            .fold(0, |a,b| a+b) + self.day()
-    }
-
-    fn is_leap_year(&self) -> bool {
-        let year = self.year();
-        if year % 4 != 0 {
-            return false
-        } else if year % 100 != 0 {
-            return true
-        } else if year % 400 != 0 {
-            return false
-        } else {
-            return true
-        }
-    }
-
-    fn days_in_month(&self) -> u32 {
-        match self.month() {
-            /* Jan */ 1 => 31,
-            /* Feb */ 2 => if self.is_leap_year() { 29 } else { 28 },
-            /* Mar */ 3 => 31,
-            /* Apr */ 4 => 30,
-            /* May */ 5 => 31,
-            /* Jun */ 6 => 30,
-            /* Jul */ 7 => 31,
-            /* Aug */ 8 => 31,
-            /* Sep */ 9 => 30,
-            /* Oct */ 10 => 31,
-            /* Nov */ 11 => 30,
-            /* Dec */ 12 => 31,
-            _ => unreachable!()
-        }
-    }
-}
-
-impl<'a, 'b> std::ops::Add<&'b NaiveDate> for &'a NaiveDate {
-    type Output = NaiveDate;
-
-    fn add(self, other: &'b NaiveDate) -> NaiveDate {
-        assert_eq!(*other, NaiveDate(0, 0, 1));
-        self.succ()
-    }
-}
-
-impl std::iter::Step for NaiveDate {
-    fn steps_between(_: &Self, _: &Self) -> Option<usize> {
-        unimplemented!()
-    }
-
-    fn forward_checked(start: Self, n: usize) -> Option<Self> {
-        Some((0..n).fold(start, |x, _| x.succ()))
-    }
-
-    fn backward_checked(_: Self, _: usize) -> Option<Self> {
-        unimplemented!()
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub enum Weekday {
-    Mon,
-    Tue,
-    Wed,
-    Thu,
-    Fri,
-    Sat,
-    Sun,
-}
-
-impl Weekday {
-    pub fn num_days_from_monday(&self) -> u32 {
-        use Weekday::*;
-        match *self {
-            Mon => 0,
-            Tue => 1,
-            Wed => 2,
-            Thu => 3,
-            Fri => 4,
-            Sat => 5,
-            Sun => 6,
-        }
-    }
-
-    pub fn num_days_from_sunday(&self) -> u32 {
-        use Weekday::*;
-        match *self {
-            Sun => 0,
-            Mon => 1,
-            Tue => 2,
-            Wed => 3,
-            Thu => 4,
-            Fri => 5,
-            Sat => 6,
-        }
-    }
-}
-
-/// `GroupBy` implementation.
-struct GroupBy<It: Iterator, F> {
-    it: std::iter::Peekable<It>,
-    f: F,
-}
-
-impl<It, F> Clone for GroupBy<It, F>
-where
-    It: Iterator + Clone,
-    It::Item: Clone,
-    F: Clone,
-{
-    fn clone(&self) -> Self {
-        GroupBy {
-            it: self.it.clone(),
-            f: self.f.clone(),
-        }
-    }
-}
-
-impl<'a, G, It: 'a, F: 'a> Iterator for GroupBy<It, F>
-where It: Iterator + Clone,
-      It::Item: Clone,
-      F: Clone + FnMut(&It::Item) -> G,
-      G: Eq + Clone
-{
-    type Item = (G, InGroup<std::iter::Peekable<It>, F, G>);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.it.peek().map(&mut self.f).map(|key| {
-            let start = self.it.clone();
-            while let Some(k) = self.it.peek().map(&mut self.f) {
-                if key != k {
-                    break;
-                }
-                self.it.next();
-            }
-
-            (key.clone(), InGroup {
-                it: start,
-                f: self.f.clone(),
-                g: key
-            })
-        })
-    }
-}
-
-#[derive(Copy, Clone)]
-struct InGroup<It, F, G> {
-    it: It,
-    f: F,
-    g: G
-}
-
-impl<It: Iterator, F: FnMut(&It::Item) -> G, G: Eq> Iterator for InGroup<It, F, G> {
-    type Item = It::Item;
-
-    fn next(&mut self) -> Option<It::Item> {
-        self.it.next().and_then(|x| {
-            if (self.f)(&x) == self.g { Some(x) } else { None }
-        })
-    }
-}
-
-trait IteratorExt: Iterator + Sized {
-    fn group_by<G, F>(self, f: F) -> GroupBy<Self, F>
-    where F: Clone + FnMut(&Self::Item) -> G,
-          G: Eq
-    {
-        GroupBy { it: self.peekable(), f }
-    }
-
-    fn join(mut self, sep: &str) -> String
-    where Self::Item: std::fmt::Display {
-        let mut s = String::new();
-        if let Some(e) = self.next() {
-            write!(s, "{}", e).unwrap();
-            for e in self {
-                s.push_str(sep);
-                write!(s, "{}", e).unwrap();
-            }
-        }
-        s
-    }
-
-    // HACK(eddyb): only needed because `impl Trait` can't be
-    // used with trait methods: `.foo()` becomes `.__(foo)`.
-    fn __<F, R>(self, f: F) -> R
-    where F: FnOnce(Self) -> R {
-        f(self)
-    }
-}
-
-impl<It> IteratorExt for It where It: Iterator {}
-
-/// Generates an iterator that yields exactly `n` spaces.
-fn spaces(n: usize) -> std::iter::Take<std::iter::Repeat<char>> {
-    std::iter::repeat(' ').take(n)
-}
-
-fn test_spaces() {
-    assert_eq!(spaces(0).collect::<String>(), "");
-    assert_eq!(spaces(10).collect::<String>(), "          ")
-}
-
-/// Returns an iterator of dates in a given year.
-fn dates_in_year(year: i32) -> impl Iterator<Item=NaiveDate>+Clone {
-    InGroup {
-        it: NaiveDate::from_ymd(year, 1, 1)..,
-        f: |d: &NaiveDate| d.year(),
-        g: year
-    }
-}
-
-fn test_dates_in_year() {
-    {
-        let mut dates = dates_in_year(2013);
-        assert_eq!(dates.next(), Some(NaiveDate::from_ymd(2013, 1, 1)));
-
-        // Check increment.
-        assert_eq!(dates.next(), Some(NaiveDate::from_ymd(2013, 1, 2)));
-
-        // Check monthly roll-over.
-        for _ in 3..31 {
-            assert!(dates.next() != None);
-        }
-
-        assert_eq!(dates.next(), Some(NaiveDate::from_ymd(2013, 1, 31)));
-        assert_eq!(dates.next(), Some(NaiveDate::from_ymd(2013, 2, 1)));
-    }
-
-    {
-        // Check length of year.
-        let mut dates = dates_in_year(2013);
-        for _ in 0..365 {
-            assert!(dates.next() != None);
-        }
-        assert_eq!(dates.next(), None);
-    }
-
-    {
-        // Check length of leap year.
-        let mut dates = dates_in_year(1984);
-        for _ in 0..366 {
-            assert!(dates.next() != None);
-        }
-        assert_eq!(dates.next(), None);
-    }
-}
-
-/// Convenience trait for verifying that a given type iterates over
-/// `NaiveDate`s.
-trait DateIterator: Iterator<Item=NaiveDate> + Clone {}
-impl<It> DateIterator for It where It: Iterator<Item=NaiveDate> + Clone {}
-
-fn test_group_by() {
-    let input = [
-        [1, 1],
-        [1, 1],
-        [1, 2],
-        [2, 2],
-        [2, 3],
-        [2, 3],
-        [3, 3]
-    ];
-
-    let by_x = input.iter().cloned().group_by(|a| a[0]);
-    let expected_1: &[&[[i32; 2]]] = &[
-        &[[1, 1], [1, 1], [1, 2]],
-        &[[2, 2], [2, 3], [2, 3]],
-        &[[3, 3]]
-    ];
-    for ((_, a), b) in by_x.zip(expected_1.iter().cloned()) {
-        assert_eq!(&a.collect::<Vec<_>>()[..], b);
-    }
-
-    let by_y = input.iter().cloned().group_by(|a| a[1]);
-    let expected_2: &[&[[i32; 2]]] = &[
-        &[[1, 1], [1, 1]],
-        &[[1, 2], [2, 2]],
-        &[[2, 3], [2, 3], [3, 3]]
-    ];
-    for ((_, a), b) in by_y.zip(expected_2.iter().cloned()) {
-        assert_eq!(&a.collect::<Vec<_>>()[..], b);
-    }
-}
-
-/// Groups an iterator of dates by month.
-fn by_month(it: impl Iterator<Item=NaiveDate> + Clone)
-            ->  impl Iterator<Item=(u32, impl Iterator<Item=NaiveDate> + Clone)> + Clone
-{
-    it.group_by(|d| d.month())
-}
-
-fn test_by_month() {
-    let mut months = dates_in_year(2013).__(by_month);
-    for (month, (_, mut date)) in (1..13).zip(&mut months) {
-        assert_eq!(date.nth(0).unwrap(), NaiveDate::from_ymd(2013, month, 1));
-    }
-    assert!(months.next().is_none());
-}
-
-/// Groups an iterator of dates by week.
-fn by_week(it: impl DateIterator)
-          -> impl Iterator<Item=(u32, impl DateIterator)> + Clone
-{
-    // We go forward one day because `isoweekdate` considers the week to start on a Monday.
-    it.group_by(|d| d.succ().isoweekdate().1)
-}
-
-fn test_isoweekdate() {
-    fn weeks_uniq(year: i32) -> Vec<((i32, u32), u32)> {
-        let mut weeks = dates_in_year(year).map(|d| d.isoweekdate())
-            .map(|(y,w,_)| (y,w));
-        let mut result = vec![];
-        let mut accum = (weeks.next().unwrap(), 1);
-        for yw in weeks {
-            if accum.0 == yw {
-                accum.1 += 1;
-            } else {
-                result.push(accum);
-                accum = (yw, 1);
-            }
-        }
-        result.push(accum);
-        result
-    }
-
-    let wu_1984 = weeks_uniq(1984);
-    assert_eq!(&wu_1984[..2], &[((1983, 52), 1), ((1984, 1), 7)]);
-    assert_eq!(&wu_1984[wu_1984.len()-2..], &[((1984, 52), 7), ((1985, 1), 1)]);
-
-    let wu_2013 = weeks_uniq(2013);
-    assert_eq!(&wu_2013[..2], &[((2013, 1), 6), ((2013, 2), 7)]);
-    assert_eq!(&wu_2013[wu_2013.len()-2..], &[((2013, 52), 7), ((2014, 1), 2)]);
-
-    let wu_2015 = weeks_uniq(2015);
-    assert_eq!(&wu_2015[..2], &[((2015, 1), 4), ((2015, 2), 7)]);
-    assert_eq!(&wu_2015[wu_2015.len()-2..], &[((2015, 52), 7), ((2015, 53), 4)]);
-}
-
-fn test_by_week() {
-    let mut weeks = dates_in_year(2013).__(by_week);
-    assert_eq!(
-        &*weeks.next().unwrap().1.collect::<Vec<_>>(),
-        &[
-            NaiveDate::from_ymd(2013, 1, 1),
-            NaiveDate::from_ymd(2013, 1, 2),
-            NaiveDate::from_ymd(2013, 1, 3),
-            NaiveDate::from_ymd(2013, 1, 4),
-            NaiveDate::from_ymd(2013, 1, 5),
-        ]
-    );
-    assert_eq!(
-        &*weeks.next().unwrap().1.collect::<Vec<_>>(),
-        &[
-            NaiveDate::from_ymd(2013, 1, 6),
-            NaiveDate::from_ymd(2013, 1, 7),
-            NaiveDate::from_ymd(2013, 1, 8),
-            NaiveDate::from_ymd(2013, 1, 9),
-            NaiveDate::from_ymd(2013, 1, 10),
-            NaiveDate::from_ymd(2013, 1, 11),
-            NaiveDate::from_ymd(2013, 1, 12),
-        ]
-    );
-    assert_eq!(weeks.next().unwrap().1.nth(0).unwrap(), NaiveDate::from_ymd(2013, 1, 13));
-}
-
-/// The number of columns per day in the formatted output.
-const COLS_PER_DAY: u32 = 3;
-
-/// The number of columns per week in the formatted output.
-const COLS_PER_WEEK: u32 = 7 * COLS_PER_DAY;
-
-/// Formats an iterator of weeks into an iterator of strings.
-fn format_weeks(it: impl Iterator<Item = impl DateIterator>) -> impl Iterator<Item=String> {
-    it.map(|week| {
-        let mut buf = String::with_capacity((COLS_PER_DAY * COLS_PER_WEEK + 2) as usize);
-
-        // Format each day into its own cell and append to target string.
-        let mut last_day = 0;
-        let mut first = true;
-        for d in week {
-            last_day = d.weekday().num_days_from_sunday();
-
-            // Insert enough filler to align the first day with its respective day-of-week.
-            if first {
-                buf.extend(spaces((COLS_PER_DAY * last_day) as usize));
-                first = false;
-            }
-
-            write!(buf, " {:>2}", d.day()).unwrap();
-        }
-
-        // Insert more filler at the end to fill up the remainder of the week,
-        // if its a short week (e.g., at the end of the month).
-        buf.extend(spaces((COLS_PER_DAY * (6 - last_day)) as usize));
-        buf
-    })
-}
-
-fn test_format_weeks() {
-    let jan_2013 = dates_in_year(2013)
-        .__(by_month).next() // pick January 2013 for testing purposes
-        // NOTE: This `map` is because `next` returns an `Option<_>`.
-        .map(|(_, month)|
-            month.__(by_week)
-                 .map(|(_, weeks)| weeks)
-                 .__(format_weeks)
-                 .join("\n"));
-
-    assert_eq!(
-        jan_2013.as_ref().map(|s| &**s),
-        Some("        1  2  3  4  5\n\
-           \x20 6  7  8  9 10 11 12\n\
-           \x2013 14 15 16 17 18 19\n\
-           \x2020 21 22 23 24 25 26\n\
-           \x2027 28 29 30 31      ")
-    );
-}
-
-/// Formats the name of a month, centered on `COLS_PER_WEEK`.
-fn month_title(month: u32) -> String {
-    const MONTH_NAMES: &'static [&'static str] = &[
-        "January", "February", "March", "April", "May", "June",
-        "July", "August", "September", "October", "November", "December"
-    ];
-    assert_eq!(MONTH_NAMES.len(), 12);
-
-    // Determine how many spaces before and after the month name
-    // we need to center it over the formatted weeks in the month.
-    let name = MONTH_NAMES[(month - 1) as usize];
-    assert!(name.len() < COLS_PER_WEEK as usize);
-    let before = (COLS_PER_WEEK as usize - name.len()) / 2;
-    let after = COLS_PER_WEEK as usize - name.len() - before;
-
-    // Note: being slightly more verbose to avoid extra allocations.
-    let mut result = String::with_capacity(COLS_PER_WEEK as usize);
-    result.extend(spaces(before));
-    result.push_str(name);
-    result.extend(spaces(after));
-    result
-}
-
-fn test_month_title() {
-    assert_eq!(month_title(1).len(), COLS_PER_WEEK as usize);
-}
-
-/// Formats a month.
-fn format_month(it: impl DateIterator) -> impl Iterator<Item=String> {
-    let mut month_days = it.peekable();
-    let title = month_title(month_days.peek().unwrap().month());
-
-    Some(title).into_iter()
-        .chain(month_days.__(by_week)
-            .map(|(_, week)| week)
-            .__(format_weeks))
-}
-
-fn test_format_month() {
-    let month_fmt = dates_in_year(2013)
-        .__(by_month).next() // Pick January as a test case
-        .map(|(_, days)| days.into_iter()
-            .__(format_month)
-            .join("\n"));
-
-    assert_eq!(
-        month_fmt.as_ref().map(|s| &**s),
-        Some("       January       \n\
-           \x20       1  2  3  4  5\n\
-           \x20 6  7  8  9 10 11 12\n\
-           \x2013 14 15 16 17 18 19\n\
-           \x2020 21 22 23 24 25 26\n\
-           \x2027 28 29 30 31      ")
-    );
-}
-
-/// Formats an iterator of months.
-fn format_months(it: impl Iterator<Item = impl DateIterator>)
-                -> impl Iterator<Item=impl Iterator<Item=String>>
-{
-    it.map(format_month)
-}
-
-/// Takes an iterator of iterators of strings; the sub-iterators are consumed
-/// in lock-step, with their elements joined together.
-trait PasteBlocks: Iterator + Sized
-where Self::Item: Iterator<Item = String> {
-    fn paste_blocks(self, sep_width: usize) -> PasteBlocksIter<Self::Item> {
-        PasteBlocksIter {
-            iters: self.collect(),
-            cache: vec![],
-            col_widths: None,
-            sep_width: sep_width,
-        }
-    }
-}
-
-impl<It> PasteBlocks for It where It: Iterator, It::Item: Iterator<Item=String> {}
-
-struct PasteBlocksIter<StrIt>
-where StrIt: Iterator<Item=String> {
-    iters: Vec<StrIt>,
-    cache: Vec<Option<String>>,
-    col_widths: Option<Vec<usize>>,
-    sep_width: usize,
-}
-
-impl<StrIt> Iterator for PasteBlocksIter<StrIt>
-where StrIt: Iterator<Item=String> {
-    type Item = String;
-
-    fn next(&mut self) -> Option<String> {
-        self.cache.clear();
-
-        // `cache` is now the next line from each iterator.
-        self.cache.extend(self.iters.iter_mut().map(|it| it.next()));
-
-        // If every line in `cache` is `None`, we have nothing further to do.
-        if self.cache.iter().all(|e| e.is_none()) { return None }
-
-        // Get the column widths if we haven't already.
-        let col_widths = match self.col_widths {
-            Some(ref v) => &**v,
-            None => {
-                self.col_widths = Some(self.cache.iter()
-                    .map(|ms| ms.as_ref().map(|s| s.len()).unwrap_or(0))
-                    .collect());
-                &**self.col_widths.as_ref().unwrap()
-            }
-        };
-
-        // Fill in any `None`s with spaces.
-        let mut parts = col_widths.iter().cloned().zip(self.cache.iter_mut())
-            .map(|(w,ms)| ms.take().unwrap_or_else(|| spaces(w).collect()));
-
-        // Join them all together.
-        let first = parts.next().unwrap_or(String::new());
-        let sep_width = self.sep_width;
-        Some(parts.fold(first, |mut accum, next| {
-            accum.extend(spaces(sep_width));
-            accum.push_str(&next);
-            accum
-        }))
-    }
-}
-
-fn test_paste_blocks() {
-    let row = dates_in_year(2013)
-        .__(by_month).map(|(_, days)| days)
-        .take(3)
-        .__(format_months)
-        .paste_blocks(1)
-        .join("\n");
-    assert_eq!(
-        &*row,
-        "       January              February                March        \n\
-      \x20       1  2  3  4  5                  1  2                  1  2\n\
-      \x20 6  7  8  9 10 11 12   3  4  5  6  7  8  9   3  4  5  6  7  8  9\n\
-      \x2013 14 15 16 17 18 19  10 11 12 13 14 15 16  10 11 12 13 14 15 16\n\
-      \x2020 21 22 23 24 25 26  17 18 19 20 21 22 23  17 18 19 20 21 22 23\n\
-      \x2027 28 29 30 31        24 25 26 27 28        24 25 26 27 28 29 30\n\
-      \x20                                            31                  "
-    );
-}
-
-/// Produces an iterator that yields `n` elements at a time.
-trait Chunks: Iterator + Sized {
-    fn chunks(self, n: usize) -> ChunksIter<Self> {
-        assert!(n > 0);
-        ChunksIter {
-            it: self,
-            n: n,
-        }
-    }
-}
-
-impl<It> Chunks for It where It: Iterator {}
-
-struct ChunksIter<It>
-where It: Iterator {
-    it: It,
-    n: usize,
-}
-
-// Note: `chunks` in Rust is more-or-less impossible without overhead of some kind.
-// Aliasing rules mean you need to add dynamic borrow checking, and the design of
-// `Iterator` means that you need to have the iterator's state kept in an allocation
-// that is jointly owned by the iterator itself and the sub-iterator.
-// As such, I've chosen to cop-out and just heap-allocate each chunk.
-
-impl<It> Iterator for ChunksIter<It>
-where It: Iterator {
-    type Item = Vec<It::Item>;
-
-    fn next(&mut self) -> Option<Vec<It::Item>> {
-        let first = self.it.next()?;
-
-        let mut result = Vec::with_capacity(self.n);
-        result.push(first);
-
-        Some((&mut self.it).take(self.n-1)
-            .fold(result, |mut acc, next| { acc.push(next); acc }))
-    }
-}
-
-fn test_chunks() {
-    let r = &[1, 2, 3, 4, 5, 6, 7];
-    let c = r.iter().cloned().chunks(3).collect::<Vec<_>>();
-    assert_eq!(&*c, &[vec![1, 2, 3], vec![4, 5, 6], vec![7]]);
-}
-
-/// Formats a year.
-fn format_year(year: i32, months_per_row: usize) -> String {
-    const COL_SPACING: usize = 1;
-
-    // Start by generating all dates for the given year.
-    dates_in_year(year)
-
-        // Group them by month and throw away month number.
-        .__(by_month).map(|(_, days)| days)
-
-        // Group the months into horizontal rows.
-        .chunks(months_per_row)
-
-        // Format each row...
-        .map(|r| r.into_iter()
-            // ... by formatting each month ...
-            .__(format_months)
-
-            // ... and horizontally pasting each respective month's lines together.
-            .paste_blocks(COL_SPACING)
-            .join("\n")
-        )
-
-        // Insert a blank line between each row.
-        .join("\n\n")
-}
-
-fn test_format_year() {
-    const MONTHS_PER_ROW: usize = 3;
-
-    macro_rules! assert_eq_cal {
-        ($lhs:expr, $rhs:expr) => {
-            if $lhs != $rhs {
-                println!("got:\n```\n{}\n```\n", $lhs.replace(" ", "."));
-                println!("expected:\n```\n{}\n```", $rhs.replace(" ", "."));
-                panic!("calendars didn't match!");
-            }
-        }
-    }
-
-    assert_eq_cal!(&format_year(1984, MONTHS_PER_ROW), "\
-\x20      January              February                March        \n\
-\x20 1  2  3  4  5  6  7            1  2  3  4               1  2  3\n\
-\x20 8  9 10 11 12 13 14   5  6  7  8  9 10 11   4  5  6  7  8  9 10\n\
-\x2015 16 17 18 19 20 21  12 13 14 15 16 17 18  11 12 13 14 15 16 17\n\
-\x2022 23 24 25 26 27 28  19 20 21 22 23 24 25  18 19 20 21 22 23 24\n\
-\x2029 30 31              26 27 28 29           25 26 27 28 29 30 31\n\
-\n\
-\x20       April                  May                  June         \n\
-\x20 1  2  3  4  5  6  7         1  2  3  4  5                  1  2\n\
-\x20 8  9 10 11 12 13 14   6  7  8  9 10 11 12   3  4  5  6  7  8  9\n\
-\x2015 16 17 18 19 20 21  13 14 15 16 17 18 19  10 11 12 13 14 15 16\n\
-\x2022 23 24 25 26 27 28  20 21 22 23 24 25 26  17 18 19 20 21 22 23\n\
-\x2029 30                 27 28 29 30 31        24 25 26 27 28 29 30\n\
-\n\
-\x20       July                 August               September      \n\
-\x20 1  2  3  4  5  6  7            1  2  3  4                     1\n\
-\x20 8  9 10 11 12 13 14   5  6  7  8  9 10 11   2  3  4  5  6  7  8\n\
-\x2015 16 17 18 19 20 21  12 13 14 15 16 17 18   9 10 11 12 13 14 15\n\
-\x2022 23 24 25 26 27 28  19 20 21 22 23 24 25  16 17 18 19 20 21 22\n\
-\x2029 30 31              26 27 28 29 30 31     23 24 25 26 27 28 29\n\
-\x20                                            30                  \n\
-\n\
-\x20      October              November              December       \n\
-\x20    1  2  3  4  5  6               1  2  3                     1\n\
-\x20 7  8  9 10 11 12 13   4  5  6  7  8  9 10   2  3  4  5  6  7  8\n\
-\x2014 15 16 17 18 19 20  11 12 13 14 15 16 17   9 10 11 12 13 14 15\n\
-\x2021 22 23 24 25 26 27  18 19 20 21 22 23 24  16 17 18 19 20 21 22\n\
-\x2028 29 30 31           25 26 27 28 29 30     23 24 25 26 27 28 29\n\
-\x20                                            30 31               ");
-
-    assert_eq_cal!(&format_year(2015, MONTHS_PER_ROW), "\
-\x20      January              February                March        \n\
-\x20             1  2  3   1  2  3  4  5  6  7   1  2  3  4  5  6  7\n\
-\x20 4  5  6  7  8  9 10   8  9 10 11 12 13 14   8  9 10 11 12 13 14\n\
-\x2011 12 13 14 15 16 17  15 16 17 18 19 20 21  15 16 17 18 19 20 21\n\
-\x2018 19 20 21 22 23 24  22 23 24 25 26 27 28  22 23 24 25 26 27 28\n\
-\x2025 26 27 28 29 30 31                        29 30 31            \n\
-\n\
-\x20       April                  May                  June         \n\
-\x20          1  2  3  4                  1  2      1  2  3  4  5  6\n\
-\x20 5  6  7  8  9 10 11   3  4  5  6  7  8  9   7  8  9 10 11 12 13\n\
-\x2012 13 14 15 16 17 18  10 11 12 13 14 15 16  14 15 16 17 18 19 20\n\
-\x2019 20 21 22 23 24 25  17 18 19 20 21 22 23  21 22 23 24 25 26 27\n\
-\x2026 27 28 29 30        24 25 26 27 28 29 30  28 29 30            \n\
-\x20                      31                                        \n\
-\n\
-\x20       July                 August               September      \n\
-\x20          1  2  3  4                     1         1  2  3  4  5\n\
-\x20 5  6  7  8  9 10 11   2  3  4  5  6  7  8   6  7  8  9 10 11 12\n\
-\x2012 13 14 15 16 17 18   9 10 11 12 13 14 15  13 14 15 16 17 18 19\n\
-\x2019 20 21 22 23 24 25  16 17 18 19 20 21 22  20 21 22 23 24 25 26\n\
-\x2026 27 28 29 30 31     23 24 25 26 27 28 29  27 28 29 30         \n\
-\x20                      30 31                                     \n\
-\n\
-\x20      October              November              December       \n\
-\x20             1  2  3   1  2  3  4  5  6  7         1  2  3  4  5\n\
-\x20 4  5  6  7  8  9 10   8  9 10 11 12 13 14   6  7  8  9 10 11 12\n\
-\x2011 12 13 14 15 16 17  15 16 17 18 19 20 21  13 14 15 16 17 18 19\n\
-\x2018 19 20 21 22 23 24  22 23 24 25 26 27 28  20 21 22 23 24 25 26\n\
-\x2025 26 27 28 29 30 31  29 30                 27 28 29 30 31      ");
-}
-
-fn main() {
-    // Run tests.
-    test_spaces();
-    test_dates_in_year();
-    test_group_by();
-    test_by_month();
-    test_isoweekdate();
-    test_by_week();
-    test_format_weeks();
-    test_month_title();
-    test_format_month();
-    test_paste_blocks();
-    test_chunks();
-    test_format_year();
-}