third_party/rust_crates/vendor/chrono-0.4.42/src/weekday_set.rs - fuchsia - Git at Google

 use core::{
     fmt::{self, Debug},
     iter::FusedIterator,
 };

 use crate::Weekday;

 /// A collection of [`Weekday`]s stored as a single byte.
 ///
 /// This type is `Copy` and provides efficient set-like and slice-like operations.
 /// Many operations are `const` as well.
 ///
 /// Implemented as a bitmask where bits 1-7 correspond to Monday-Sunday.
 #[derive(Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct WeekdaySet(u8); // Invariant: the 8-th bit is always 0.

 impl WeekdaySet {
     /// Create a `WeekdaySet` from an array of [`Weekday`]s.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::EMPTY, WeekdaySet::from_array([]));
     /// assert_eq!(WeekdaySet::single(Mon), WeekdaySet::from_array([Mon]));
     /// assert_eq!(WeekdaySet::ALL, WeekdaySet::from_array([Mon, Tue, Wed, Thu, Fri, Sat, Sun]));
     /// ```
     pub const fn from_array<const C: usize>(days: [Weekday; C]) -> Self {
         let mut acc = Self::EMPTY;
         let mut idx = 0;
         while idx < days.len() {
             acc.0 |= Self::single(days[idx]).0;
             idx += 1;
         }
         acc
     }

     /// Create a `WeekdaySet` from a single [`Weekday`].
     pub const fn single(weekday: Weekday) -> Self {
         match weekday {
             Weekday::Mon => Self(0b000_0001),
             Weekday::Tue => Self(0b000_0010),
             Weekday::Wed => Self(0b000_0100),
             Weekday::Thu => Self(0b000_1000),
             Weekday::Fri => Self(0b001_0000),
             Weekday::Sat => Self(0b010_0000),
             Weekday::Sun => Self(0b100_0000),
         }
     }

     /// Returns `Some(day)` if this collection contains exactly one day.
     ///
     /// Returns `None` otherwise.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).single_day(), Some(Mon));
     /// assert_eq!(WeekdaySet::from_array([Mon, Tue]).single_day(), None);
     /// assert_eq!(WeekdaySet::EMPTY.single_day(), None);
     /// assert_eq!(WeekdaySet::ALL.single_day(), None);
     /// ```
     pub const fn single_day(self) -> Option<Weekday> {
         match self {
             Self(0b000_0001) => Some(Weekday::Mon),
             Self(0b000_0010) => Some(Weekday::Tue),
             Self(0b000_0100) => Some(Weekday::Wed),
             Self(0b000_1000) => Some(Weekday::Thu),
             Self(0b001_0000) => Some(Weekday::Fri),
             Self(0b010_0000) => Some(Weekday::Sat),
             Self(0b100_0000) => Some(Weekday::Sun),
             _ => None,
         }
     }

     /// Adds a day to the collection.
     ///
     /// Returns `true` if the day was new to the collection.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// let mut weekdays = WeekdaySet::single(Mon);
     /// assert!(weekdays.insert(Tue));
     /// assert!(!weekdays.insert(Tue));
     /// ```
     pub fn insert(&mut self, day: Weekday) -> bool {
         if self.contains(day) {
             return false;
         }

         self.0 |= Self::single(day).0;
         true
     }

     /// Removes a day from the collection.
     ///
     /// Returns `true` if the collection did contain the day.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// let mut weekdays = WeekdaySet::single(Mon);
     /// assert!(weekdays.remove(Mon));
     /// assert!(!weekdays.remove(Mon));
     /// ```
     pub fn remove(&mut self, day: Weekday) -> bool {
         if self.contains(day) {
             self.0 &= !Self::single(day).0;
             return true;
         }

         false
     }

     /// Returns `true` if `other` contains all days in `self`.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert!(WeekdaySet::single(Mon).is_subset(WeekdaySet::ALL));
     /// assert!(!WeekdaySet::single(Mon).is_subset(WeekdaySet::EMPTY));
     /// assert!(WeekdaySet::EMPTY.is_subset(WeekdaySet::single(Mon)));
     /// ```
     pub const fn is_subset(self, other: Self) -> bool {
         self.intersection(other).0 == self.0
     }

     /// Returns days that are in both `self` and `other`.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).intersection(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
     /// assert_eq!(WeekdaySet::single(Mon).intersection(WeekdaySet::single(Tue)), WeekdaySet::EMPTY);
     /// assert_eq!(WeekdaySet::ALL.intersection(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
     /// assert_eq!(WeekdaySet::ALL.intersection(WeekdaySet::EMPTY), WeekdaySet::EMPTY);
     /// ```
     pub const fn intersection(self, other: Self) -> Self {
         Self(self.0 & other.0)
     }

     /// Returns days that are in either `self` or `other`.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).union(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
     /// assert_eq!(WeekdaySet::single(Mon).union(WeekdaySet::single(Tue)), WeekdaySet::from_array([Mon, Tue]));
     /// assert_eq!(WeekdaySet::ALL.union(WeekdaySet::single(Mon)), WeekdaySet::ALL);
     /// assert_eq!(WeekdaySet::ALL.union(WeekdaySet::EMPTY), WeekdaySet::ALL);
     /// ```
     pub const fn union(self, other: Self) -> Self {
         Self(self.0 | other.0)
     }

     /// Returns days that are in `self` or `other` but not in both.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).symmetric_difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
     /// assert_eq!(WeekdaySet::single(Mon).symmetric_difference(WeekdaySet::single(Tue)), WeekdaySet::from_array([Mon, Tue]));
     /// assert_eq!(
     ///     WeekdaySet::ALL.symmetric_difference(WeekdaySet::single(Mon)),
     ///     WeekdaySet::from_array([Tue, Wed, Thu, Fri, Sat, Sun]),
     /// );
     /// assert_eq!(WeekdaySet::ALL.symmetric_difference(WeekdaySet::EMPTY), WeekdaySet::ALL);
     /// ```
     pub const fn symmetric_difference(self, other: Self) -> Self {
         Self(self.0 ^ other.0)
     }

     /// Returns days that are in `self` but not in `other`.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
     /// assert_eq!(WeekdaySet::single(Mon).difference(WeekdaySet::single(Tue)), WeekdaySet::single(Mon));
     /// assert_eq!(WeekdaySet::EMPTY.difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
     /// ```
     pub const fn difference(self, other: Self) -> Self {
         Self(self.0 & !other.0)
     }

     /// Get the first day in the collection, starting from Monday.
     ///
     /// Returns `None` if the collection is empty.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).first(), Some(Mon));
     /// assert_eq!(WeekdaySet::single(Tue).first(), Some(Tue));
     /// assert_eq!(WeekdaySet::ALL.first(), Some(Mon));
     /// assert_eq!(WeekdaySet::EMPTY.first(), None);
     /// ```
     pub const fn first(self) -> Option<Weekday> {
         if self.is_empty() {
             return None;
         }

         // Find the first non-zero bit.
         let bit = 1 << self.0.trailing_zeros();

         Self(bit).single_day()
     }

     /// Get the last day in the collection, starting from Sunday.
     ///
     /// Returns `None` if the collection is empty.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).last(), Some(Mon));
     /// assert_eq!(WeekdaySet::single(Sun).last(), Some(Sun));
     /// assert_eq!(WeekdaySet::from_array([Mon, Tue]).last(), Some(Tue));
     /// assert_eq!(WeekdaySet::EMPTY.last(), None);
     /// ```
     pub fn last(self) -> Option<Weekday> {
         if self.is_empty() {
             return None;
         }

         // Find the last non-zero bit.
         let bit = 1 << (7 - self.0.leading_zeros());

         Self(bit).single_day()
     }

     /// Split the collection in two at the given day.
     ///
     /// Returns a tuple `(before, after)`. `before` contains all days starting from Monday
     /// up to but __not__ including `weekday`. `after` contains all days starting from `weekday`
     /// up to and including Sunday.
     const fn split_at(self, weekday: Weekday) -> (Self, Self) {
         let days_after = 0b1000_0000 - Self::single(weekday).0;
         let days_before = days_after ^ 0b0111_1111;
         (Self(self.0 & days_before), Self(self.0 & days_after))
     }

     /// Iterate over the [`Weekday`]s in the collection starting from a given day.
     ///
     /// Wraps around from Sunday to Monday if necessary.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// let weekdays = WeekdaySet::from_array([Mon, Wed, Fri]);
     /// let mut iter = weekdays.iter(Wed);
     /// assert_eq!(iter.next(), Some(Wed));
     /// assert_eq!(iter.next(), Some(Fri));
     /// assert_eq!(iter.next(), Some(Mon));
     /// assert_eq!(iter.next(), None);
     /// ```
     pub const fn iter(self, start: Weekday) -> WeekdaySetIter {
         WeekdaySetIter { days: self, start }
     }

     /// Returns `true` if the collection contains the given day.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert!(WeekdaySet::single(Mon).contains(Mon));
     /// assert!(WeekdaySet::from_array([Mon, Tue]).contains(Tue));
     /// assert!(!WeekdaySet::single(Mon).contains(Tue));
     /// ```
     pub const fn contains(self, day: Weekday) -> bool {
         self.0 & Self::single(day).0 != 0
     }

     /// Returns `true` if the collection is empty.
     ///
     /// # Example
     /// ```
     /// # use chrono::{Weekday, WeekdaySet};
     /// assert!(WeekdaySet::EMPTY.is_empty());
     /// assert!(!WeekdaySet::single(Weekday::Mon).is_empty());
     /// ```
     pub const fn is_empty(self) -> bool {
         self.len() == 0
     }
     /// Returns the number of days in the collection.
     ///
     /// # Example
     /// ```
     /// # use chrono::WeekdaySet;
     /// use chrono::Weekday::*;
     /// assert_eq!(WeekdaySet::single(Mon).len(), 1);
     /// assert_eq!(WeekdaySet::from_array([Mon, Wed, Fri]).len(), 3);
     /// assert_eq!(WeekdaySet::ALL.len(), 7);
     /// ```
     pub const fn len(self) -> u8 {
         self.0.count_ones() as u8
     }

     /// An empty `WeekdaySet`.
     pub const EMPTY: Self = Self(0b000_0000);
     /// A `WeekdaySet` containing all seven `Weekday`s.
     pub const ALL: Self = Self(0b111_1111);
 }

 /// Print the underlying bitmask, padded to 7 bits.
 ///
 /// # Example
 /// ```
 /// # use chrono::WeekdaySet;
 /// use chrono::Weekday::*;
 /// assert_eq!(format!("{:?}", WeekdaySet::single(Mon)), "WeekdaySet(0000001)");
 /// assert_eq!(format!("{:?}", WeekdaySet::single(Tue)), "WeekdaySet(0000010)");
 /// assert_eq!(format!("{:?}", WeekdaySet::ALL), "WeekdaySet(1111111)");
 /// ```
 impl Debug for WeekdaySet {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "WeekdaySet({:0>7b})", self.0)
     }
 }

 /// An iterator over a collection of weekdays, starting from a given day.
 ///
 /// See [`WeekdaySet::iter()`].
 #[derive(Debug, Clone)]
 pub struct WeekdaySetIter {
     days: WeekdaySet,
     start: Weekday,
 }

 impl Iterator for WeekdaySetIter {
     type Item = Weekday;

     fn next(&mut self) -> Option<Self::Item> {
         if self.days.is_empty() {
             return None;
         }

         // Split the collection in two at `start`.
         // Look for the first day among the days after `start` first, including `start` itself.
         // If there are no days after `start`, look for the first day among the days before `start`.
         let (before, after) = self.days.split_at(self.start);
         let days = if after.is_empty() { before } else { after };

         let next = days.first().expect("the collection is not empty");
         self.days.remove(next);
         Some(next)
     }
 }

 impl DoubleEndedIterator for WeekdaySetIter {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.days.is_empty() {
             return None;
         }

         // Split the collection in two at `start`.
         // Look for the last day among the days before `start` first, NOT including `start` itself.
         // If there are no days before `start`, look for the last day among the days after `start`.
         let (before, after) = self.days.split_at(self.start);
         let days = if before.is_empty() { after } else { before };

         let next_back = days.last().expect("the collection is not empty");
         self.days.remove(next_back);
         Some(next_back)
     }
 }

 impl ExactSizeIterator for WeekdaySetIter {
     fn len(&self) -> usize {
         self.days.len().into()
     }
 }

 impl FusedIterator for WeekdaySetIter {}

 /// Print the collection as a slice-like list of weekdays.
 ///
 /// # Example
 /// ```
 /// # use chrono::WeekdaySet;
 /// use chrono::Weekday::*;
 /// assert_eq!("[]", WeekdaySet::EMPTY.to_string());
 /// assert_eq!("[Mon]", WeekdaySet::single(Mon).to_string());
 /// assert_eq!("[Mon, Fri, Sun]", WeekdaySet::from_array([Mon, Fri, Sun]).to_string());
 /// ```
 impl fmt::Display for WeekdaySet {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "[")?;
         let mut iter = self.iter(Weekday::Mon);
         if let Some(first) = iter.next() {
             write!(f, "{first}")?;
         }
         for weekday in iter {
             write!(f, ", {weekday}")?;
         }
         write!(f, "]")
     }
 }

 impl FromIterator<Weekday> for WeekdaySet {
     fn from_iter<T: IntoIterator<Item = Weekday>>(iter: T) -> Self {
         iter.into_iter().map(Self::single).fold(Self::EMPTY, Self::union)
     }
 }

 #[cfg(test)]
 mod tests {
     use crate::Weekday;

     use super::WeekdaySet;

     impl WeekdaySet {
         /// Iterate over all 128 possible sets, from `EMPTY` to `ALL`.
         fn iter_all() -> impl Iterator<Item = Self> {
             (0b0000_0000..0b1000_0000).map(Self)
         }
     }

     /// Panics if the 8-th bit of `self` is not 0.
     fn assert_8th_bit_invariant(days: WeekdaySet) {
         assert!(days.0 & 0b1000_0000 == 0, "the 8-th bit of {days:?} is not 0");
     }

     #[test]
     fn debug_prints_8th_bit_if_not_zero() {
         assert_eq!(format!("{:?}", WeekdaySet(0b1000_0000)), "WeekdaySet(10000000)");
     }

     #[test]
     fn bitwise_set_operations_preserve_8th_bit_invariant() {
         for set1 in WeekdaySet::iter_all() {
             for set2 in WeekdaySet::iter_all() {
                 assert_8th_bit_invariant(set1.union(set2));
                 assert_8th_bit_invariant(set1.intersection(set2));
                 assert_8th_bit_invariant(set1.symmetric_difference(set2));
             }
         }
     }

     /// Test `split_at` on all possible arguments.
     #[test]
     fn split_at_is_equivalent_to_iterating() {
         use Weekday::*;

         // `split_at()` is used in `iter()`, so we must not iterate
         // over all days with `WeekdaySet::ALL.iter(Mon)`.
         const WEEK: [Weekday; 7] = [Mon, Tue, Wed, Thu, Fri, Sat, Sun];

         for weekdays in WeekdaySet::iter_all() {
             for split_day in WEEK {
                 let expected_before: WeekdaySet = WEEK
                     .into_iter()
                     .take_while(|&day| day != split_day)
                     .filter(|&day| weekdays.contains(day))
                     .collect();
                 let expected_after: WeekdaySet = WEEK
                     .into_iter()
                     .skip_while(|&day| day != split_day)
                     .filter(|&day| weekdays.contains(day))
                     .collect();

                 assert_eq!(
                     (expected_before, expected_after),
                     weekdays.split_at(split_day),
                     "split_at({split_day}) failed for {weekdays}",
                 );
             }
         }
     }
 }
	use core::{
	fmt::{self, Debug},
	iter::FusedIterator,
	};

	use crate::Weekday;

	/// A collection of [`Weekday`]s stored as a single byte.
	///
	/// This type is `Copy` and provides efficient set-like and slice-like operations.
	/// Many operations are `const` as well.
	///
	/// Implemented as a bitmask where bits 1-7 correspond to Monday-Sunday.
	#[derive(Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
	pub struct WeekdaySet(u8); // Invariant: the 8-th bit is always 0.

	impl WeekdaySet {
	/// Create a `WeekdaySet` from an array of [`Weekday`]s.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::EMPTY, WeekdaySet::from_array([]));
	/// assert_eq!(WeekdaySet::single(Mon), WeekdaySet::from_array([Mon]));
	/// assert_eq!(WeekdaySet::ALL, WeekdaySet::from_array([Mon, Tue, Wed, Thu, Fri, Sat, Sun]));
	/// ```
	pub const fn from_array<const C: usize>(days: [Weekday; C]) -> Self {
	let mut acc = Self::EMPTY;
	let mut idx = 0;
	while idx < days.len() {
	acc.0 \|= Self::single(days[idx]).0;
	idx += 1;
	}
	acc
	}

	/// Create a `WeekdaySet` from a single [`Weekday`].
	pub const fn single(weekday: Weekday) -> Self {
	match weekday {
	Weekday::Mon => Self(0b000_0001),
	Weekday::Tue => Self(0b000_0010),
	Weekday::Wed => Self(0b000_0100),
	Weekday::Thu => Self(0b000_1000),
	Weekday::Fri => Self(0b001_0000),
	Weekday::Sat => Self(0b010_0000),
	Weekday::Sun => Self(0b100_0000),
	}
	}

	/// Returns `Some(day)` if this collection contains exactly one day.
	///
	/// Returns `None` otherwise.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).single_day(), Some(Mon));
	/// assert_eq!(WeekdaySet::from_array([Mon, Tue]).single_day(), None);
	/// assert_eq!(WeekdaySet::EMPTY.single_day(), None);
	/// assert_eq!(WeekdaySet::ALL.single_day(), None);
	/// ```
	pub const fn single_day(self) -> Option<Weekday> {
	match self {
	Self(0b000_0001) => Some(Weekday::Mon),
	Self(0b000_0010) => Some(Weekday::Tue),
	Self(0b000_0100) => Some(Weekday::Wed),
	Self(0b000_1000) => Some(Weekday::Thu),
	Self(0b001_0000) => Some(Weekday::Fri),
	Self(0b010_0000) => Some(Weekday::Sat),
	Self(0b100_0000) => Some(Weekday::Sun),
	_ => None,
	}
	}

	/// Adds a day to the collection.
	///
	/// Returns `true` if the day was new to the collection.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// let mut weekdays = WeekdaySet::single(Mon);
	/// assert!(weekdays.insert(Tue));
	/// assert!(!weekdays.insert(Tue));
	/// ```
	pub fn insert(&mut self, day: Weekday) -> bool {
	if self.contains(day) {
	return false;
	}

	self.0 \|= Self::single(day).0;
	true
	}

	/// Removes a day from the collection.
	///
	/// Returns `true` if the collection did contain the day.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// let mut weekdays = WeekdaySet::single(Mon);
	/// assert!(weekdays.remove(Mon));
	/// assert!(!weekdays.remove(Mon));
	/// ```
	pub fn remove(&mut self, day: Weekday) -> bool {
	if self.contains(day) {
	self.0 &= !Self::single(day).0;
	return true;
	}

	false
	}

	/// Returns `true` if `other` contains all days in `self`.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert!(WeekdaySet::single(Mon).is_subset(WeekdaySet::ALL));
	/// assert!(!WeekdaySet::single(Mon).is_subset(WeekdaySet::EMPTY));
	/// assert!(WeekdaySet::EMPTY.is_subset(WeekdaySet::single(Mon)));
	/// ```
	pub const fn is_subset(self, other: Self) -> bool {
	self.intersection(other).0 == self.0
	}

	/// Returns days that are in both `self` and `other`.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).intersection(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
	/// assert_eq!(WeekdaySet::single(Mon).intersection(WeekdaySet::single(Tue)), WeekdaySet::EMPTY);
	/// assert_eq!(WeekdaySet::ALL.intersection(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
	/// assert_eq!(WeekdaySet::ALL.intersection(WeekdaySet::EMPTY), WeekdaySet::EMPTY);
	/// ```
	pub const fn intersection(self, other: Self) -> Self {
	Self(self.0 & other.0)
	}

	/// Returns days that are in either `self` or `other`.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).union(WeekdaySet::single(Mon)), WeekdaySet::single(Mon));
	/// assert_eq!(WeekdaySet::single(Mon).union(WeekdaySet::single(Tue)), WeekdaySet::from_array([Mon, Tue]));
	/// assert_eq!(WeekdaySet::ALL.union(WeekdaySet::single(Mon)), WeekdaySet::ALL);
	/// assert_eq!(WeekdaySet::ALL.union(WeekdaySet::EMPTY), WeekdaySet::ALL);
	/// ```
	pub const fn union(self, other: Self) -> Self {
	Self(self.0 \| other.0)
	}

	/// Returns days that are in `self` or `other` but not in both.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).symmetric_difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
	/// assert_eq!(WeekdaySet::single(Mon).symmetric_difference(WeekdaySet::single(Tue)), WeekdaySet::from_array([Mon, Tue]));
	/// assert_eq!(
	/// WeekdaySet::ALL.symmetric_difference(WeekdaySet::single(Mon)),
	/// WeekdaySet::from_array([Tue, Wed, Thu, Fri, Sat, Sun]),
	/// );
	/// assert_eq!(WeekdaySet::ALL.symmetric_difference(WeekdaySet::EMPTY), WeekdaySet::ALL);
	/// ```
	pub const fn symmetric_difference(self, other: Self) -> Self {
	Self(self.0 ^ other.0)
	}

	/// Returns days that are in `self` but not in `other`.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
	/// assert_eq!(WeekdaySet::single(Mon).difference(WeekdaySet::single(Tue)), WeekdaySet::single(Mon));
	/// assert_eq!(WeekdaySet::EMPTY.difference(WeekdaySet::single(Mon)), WeekdaySet::EMPTY);
	/// ```
	pub const fn difference(self, other: Self) -> Self {
	Self(self.0 & !other.0)
	}

	/// Get the first day in the collection, starting from Monday.
	///
	/// Returns `None` if the collection is empty.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).first(), Some(Mon));
	/// assert_eq!(WeekdaySet::single(Tue).first(), Some(Tue));
	/// assert_eq!(WeekdaySet::ALL.first(), Some(Mon));
	/// assert_eq!(WeekdaySet::EMPTY.first(), None);
	/// ```
	pub const fn first(self) -> Option<Weekday> {
	if self.is_empty() {
	return None;
	}

	// Find the first non-zero bit.
	let bit = 1 << self.0.trailing_zeros();

	Self(bit).single_day()
	}

	/// Get the last day in the collection, starting from Sunday.
	///
	/// Returns `None` if the collection is empty.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).last(), Some(Mon));
	/// assert_eq!(WeekdaySet::single(Sun).last(), Some(Sun));
	/// assert_eq!(WeekdaySet::from_array([Mon, Tue]).last(), Some(Tue));
	/// assert_eq!(WeekdaySet::EMPTY.last(), None);
	/// ```
	pub fn last(self) -> Option<Weekday> {
	if self.is_empty() {
	return None;
	}

	// Find the last non-zero bit.
	let bit = 1 << (7 - self.0.leading_zeros());

	Self(bit).single_day()
	}

	/// Split the collection in two at the given day.
	///
	/// Returns a tuple `(before, after)`. `before` contains all days starting from Monday
	/// up to but __not__ including `weekday`. `after` contains all days starting from `weekday`
	/// up to and including Sunday.
	const fn split_at(self, weekday: Weekday) -> (Self, Self) {
	let days_after = 0b1000_0000 - Self::single(weekday).0;
	let days_before = days_after ^ 0b0111_1111;
	(Self(self.0 & days_before), Self(self.0 & days_after))
	}

	/// Iterate over the [`Weekday`]s in the collection starting from a given day.
	///
	/// Wraps around from Sunday to Monday if necessary.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// let weekdays = WeekdaySet::from_array([Mon, Wed, Fri]);
	/// let mut iter = weekdays.iter(Wed);
	/// assert_eq!(iter.next(), Some(Wed));
	/// assert_eq!(iter.next(), Some(Fri));
	/// assert_eq!(iter.next(), Some(Mon));
	/// assert_eq!(iter.next(), None);
	/// ```
	pub const fn iter(self, start: Weekday) -> WeekdaySetIter {
	WeekdaySetIter { days: self, start }
	}

	/// Returns `true` if the collection contains the given day.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert!(WeekdaySet::single(Mon).contains(Mon));
	/// assert!(WeekdaySet::from_array([Mon, Tue]).contains(Tue));
	/// assert!(!WeekdaySet::single(Mon).contains(Tue));
	/// ```
	pub const fn contains(self, day: Weekday) -> bool {
	self.0 & Self::single(day).0 != 0
	}

	/// Returns `true` if the collection is empty.
	///
	/// # Example
	/// ```
	/// # use chrono::{Weekday, WeekdaySet};
	/// assert!(WeekdaySet::EMPTY.is_empty());
	/// assert!(!WeekdaySet::single(Weekday::Mon).is_empty());
	/// ```
	pub const fn is_empty(self) -> bool {
	self.len() == 0
	}
	/// Returns the number of days in the collection.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(WeekdaySet::single(Mon).len(), 1);
	/// assert_eq!(WeekdaySet::from_array([Mon, Wed, Fri]).len(), 3);
	/// assert_eq!(WeekdaySet::ALL.len(), 7);
	/// ```
	pub const fn len(self) -> u8 {
	self.0.count_ones() as u8
	}

	/// An empty `WeekdaySet`.
	pub const EMPTY: Self = Self(0b000_0000);
	/// A `WeekdaySet` containing all seven `Weekday`s.
	pub const ALL: Self = Self(0b111_1111);
	}

	/// Print the underlying bitmask, padded to 7 bits.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!(format!("{:?}", WeekdaySet::single(Mon)), "WeekdaySet(0000001)");
	/// assert_eq!(format!("{:?}", WeekdaySet::single(Tue)), "WeekdaySet(0000010)");
	/// assert_eq!(format!("{:?}", WeekdaySet::ALL), "WeekdaySet(1111111)");
	/// ```
	impl Debug for WeekdaySet {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	write!(f, "WeekdaySet({:0>7b})", self.0)
	}
	}

	/// An iterator over a collection of weekdays, starting from a given day.
	///
	/// See [`WeekdaySet::iter()`].
	#[derive(Debug, Clone)]
	pub struct WeekdaySetIter {
	days: WeekdaySet,
	start: Weekday,
	}

	impl Iterator for WeekdaySetIter {
	type Item = Weekday;

	fn next(&mut self) -> Option<Self::Item> {
	if self.days.is_empty() {
	return None;
	}

	// Split the collection in two at `start`.
	// Look for the first day among the days after `start` first, including `start` itself.
	// If there are no days after `start`, look for the first day among the days before `start`.
	let (before, after) = self.days.split_at(self.start);
	let days = if after.is_empty() { before } else { after };

	let next = days.first().expect("the collection is not empty");
	self.days.remove(next);
	Some(next)
	}
	}

	impl DoubleEndedIterator for WeekdaySetIter {
	fn next_back(&mut self) -> Option<Self::Item> {
	if self.days.is_empty() {
	return None;
	}

	// Split the collection in two at `start`.
	// Look for the last day among the days before `start` first, NOT including `start` itself.
	// If there are no days before `start`, look for the last day among the days after `start`.
	let (before, after) = self.days.split_at(self.start);
	let days = if before.is_empty() { after } else { before };

	let next_back = days.last().expect("the collection is not empty");
	self.days.remove(next_back);
	Some(next_back)
	}
	}

	impl ExactSizeIterator for WeekdaySetIter {
	fn len(&self) -> usize {
	self.days.len().into()
	}
	}

	impl FusedIterator for WeekdaySetIter {}

	/// Print the collection as a slice-like list of weekdays.
	///
	/// # Example
	/// ```
	/// # use chrono::WeekdaySet;
	/// use chrono::Weekday::*;
	/// assert_eq!("[]", WeekdaySet::EMPTY.to_string());
	/// assert_eq!("[Mon]", WeekdaySet::single(Mon).to_string());
	/// assert_eq!("[Mon, Fri, Sun]", WeekdaySet::from_array([Mon, Fri, Sun]).to_string());
	/// ```
	impl fmt::Display for WeekdaySet {
	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
	write!(f, "[")?;
	let mut iter = self.iter(Weekday::Mon);
	if let Some(first) = iter.next() {
	write!(f, "{first}")?;
	}
	for weekday in iter {
	write!(f, ", {weekday}")?;
	}
	write!(f, "]")
	}
	}

	impl FromIterator<Weekday> for WeekdaySet {
	fn from_iter<T: IntoIterator<Item = Weekday>>(iter: T) -> Self {
	iter.into_iter().map(Self::single).fold(Self::EMPTY, Self::union)
	}
	}

	#[cfg(test)]
	mod tests {
	use crate::Weekday;

	use super::WeekdaySet;

	impl WeekdaySet {
	/// Iterate over all 128 possible sets, from `EMPTY` to `ALL`.
	fn iter_all() -> impl Iterator<Item = Self> {
	(0b0000_0000..0b1000_0000).map(Self)
	}
	}

	/// Panics if the 8-th bit of `self` is not 0.
	fn assert_8th_bit_invariant(days: WeekdaySet) {
	assert!(days.0 & 0b1000_0000 == 0, "the 8-th bit of {days:?} is not 0");
	}

	#[test]
	fn debug_prints_8th_bit_if_not_zero() {
	assert_eq!(format!("{:?}", WeekdaySet(0b1000_0000)), "WeekdaySet(10000000)");
	}

	#[test]
	fn bitwise_set_operations_preserve_8th_bit_invariant() {
	for set1 in WeekdaySet::iter_all() {
	for set2 in WeekdaySet::iter_all() {
	assert_8th_bit_invariant(set1.union(set2));
	assert_8th_bit_invariant(set1.intersection(set2));
	assert_8th_bit_invariant(set1.symmetric_difference(set2));
	}
	}
	}

	/// Test `split_at` on all possible arguments.
	#[test]
	fn split_at_is_equivalent_to_iterating() {
	use Weekday::*;

	// `split_at()` is used in `iter()`, so we must not iterate
	// over all days with `WeekdaySet::ALL.iter(Mon)`.
	const WEEK: [Weekday; 7] = [Mon, Tue, Wed, Thu, Fri, Sat, Sun];

	for weekdays in WeekdaySet::iter_all() {
	for split_day in WEEK {
	let expected_before: WeekdaySet = WEEK
	.into_iter()
	.take_while(\|&day\| day != split_day)
	.filter(\|&day\| weekdays.contains(day))
	.collect();
	let expected_after: WeekdaySet = WEEK
	.into_iter()
	.skip_while(\|&day\| day != split_day)
	.filter(\|&day\| weekdays.contains(day))
	.collect();

	assert_eq!(
	(expected_before, expected_after),
	weekdays.split_at(split_day),
	"split_at({split_day}) failed for {weekdays}",
	);
	}
	}
	}
	}