Enum Weekday

#[repr(u8)]
pub enum Weekday {
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6,
    Sunday = 7,
}

Available on crate features dep_jiff and alloc only.

A representation for the day of the week.

The default representation follows ISO 8601. That is, the week starts with Monday and numbering starts at 1. However, the various constructors and accessors support using other schemes in wide use:

• Weekday::from_monday_zero_offset builds a weekday from a scheme that starts the week on Monday at offset 0, while Weekday::to_monday_zero_offset converts to it.
• Weekday::from_monday_one_offset builds a weekday from a scheme that starts the week on Monday at offset 1 (the default representation), while Weekday::to_monday_one_offset converts to it.
• Weekday::from_sunday_zero_offset builds a weekday from a scheme that starts the week on Sunday at offset 0, while Weekday::to_sunday_zero_offset converts to it.
• Weekday::from_sunday_one_offset builds a weekday from a scheme that starts the week on Sunday at offset 1, while Weekday::to_sunday_one_offset converts to it.

Arithmetic

This type provides Weekday::wrapping_add and Weekday::wrapping_sub for performing wrapping arithmetic on weekdays. These are also available via operator overloading:

use jiff::civil::Weekday;

assert_eq!(Weekday::Monday + 1, Weekday::Tuesday);
assert_eq!(Weekday::Sunday - 1, Weekday::Saturday);

Comparisons

This type provides Eq and PartialEq trait implementations for easy comparison:

use jiff::civil::Weekday;

assert_eq!(Weekday::Wednesday, Weekday::Wednesday + 7);
assert_ne!(Weekday::Thursday, Weekday::Friday);

But this type specifically does not provide Ord or PartialOrd trait implementations. Such an implementation would require deciding whether Sunday is less than Monday or greater than Monday. The former case corresponds to a week scheme where Sunday is the first day in the week, where as the latter corresponds to a scheme where Monday is the first day. Since both schemes are in widespread use, it would be inappropriate to bake in an assumption of one or the other. Instead, one can convert a weekday into the desired offset scheme, and then compare the offsets:

use jiff::civil::Weekday;

let (sun, mon) = (Weekday::Sunday, Weekday::Monday);
assert!(sun.to_sunday_zero_offset() < mon.to_sunday_zero_offset());
assert!(sun.to_monday_zero_offset() > mon.to_monday_zero_offset());

Example

This example shows the result of converting to and from different schemes:

use jiff::civil::Weekday;

// The different representations of Monday.
assert_eq!(Weekday::Monday.to_monday_zero_offset(), 0);
assert_eq!(Weekday::Monday.to_monday_one_offset(), 1);
assert_eq!(Weekday::Monday.to_sunday_zero_offset(), 1);
assert_eq!(Weekday::Monday.to_sunday_one_offset(), 2);

// The different representations of Sunday.
assert_eq!(Weekday::Sunday.to_monday_zero_offset(), 6);
assert_eq!(Weekday::Sunday.to_monday_one_offset(), 7);
assert_eq!(Weekday::Sunday.to_sunday_zero_offset(), 0);
assert_eq!(Weekday::Sunday.to_sunday_one_offset(), 1);

Variants

Monday = 1

Tuesday = 2

Wednesday = 3

Thursday = 4

Friday = 5

Saturday = 6

Sunday = 7

Implementations

impl Weekday

pub fn from_monday_zero_offset(offset: i8) -> Result<Weekday, Error>

Convert an offset to a structured Weekday.

The offset should be from a scheme where the first day of the week is Monday and starts numbering at 0.

Errors

This returns an error when the given offset is not in the range 0..=6.

Example

use jiff::civil::Weekday;

let weekday = Weekday::from_monday_zero_offset(3)?;
assert_eq!(weekday, Weekday::Thursday);

assert!(Weekday::from_monday_zero_offset(7).is_err());
assert!(Weekday::from_monday_zero_offset(-1).is_err());

pub fn from_monday_one_offset(offset: i8) -> Result<Weekday, Error>

Convert an offset to a structured Weekday.

The offset should be from a scheme where the first day of the week is Monday and starts numbering at 1.

Errors

This returns an error when the given offset is not in the range 1..=7.

Example

use jiff::civil::Weekday;

let weekday = Weekday::from_monday_one_offset(4)?;
assert_eq!(weekday, Weekday::Thursday);

assert!(Weekday::from_monday_one_offset(8).is_err());
assert!(Weekday::from_monday_one_offset(0).is_err());

pub fn from_sunday_zero_offset(offset: i8) -> Result<Weekday, Error>

Convert an offset to a structured Weekday.

The offset should be from a scheme where the first day of the week is Sunday and starts numbering at 0.

Errors

This returns an error when the given offset is not in the range 0..=6.

Example

use jiff::civil::Weekday;

let weekday = Weekday::from_sunday_zero_offset(4)?;
assert_eq!(weekday, Weekday::Thursday);

assert!(Weekday::from_sunday_zero_offset(7).is_err());
assert!(Weekday::from_sunday_zero_offset(-1).is_err());

pub fn from_sunday_one_offset(offset: i8) -> Result<Weekday, Error>

Convert an offset to a structured Weekday.

The offset should be from a scheme where the first day of the week is Sunday and starts numbering at 1.

Errors

This returns an error when the given offset is not in the range 1..=7.

Example

use jiff::civil::Weekday;

let weekday = Weekday::from_sunday_one_offset(5)?;
assert_eq!(weekday, Weekday::Thursday);

assert!(Weekday::from_sunday_one_offset(8).is_err());
assert!(Weekday::from_sunday_one_offset(0).is_err());

pub fn to_monday_zero_offset(self) -> i8

Returns this weekday as an offset.

The offset returned is computed based on a week that starts with Monday and begins numbering at 0.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Thursday.to_monday_zero_offset(), 3);

pub fn to_monday_one_offset(self) -> i8

Returns this weekday as an offset.

The offset returned is computed based on a week that starts with Monday and begins numbering at 1.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Thursday.to_monday_one_offset(), 4);

pub fn to_sunday_zero_offset(self) -> i8

Returns this weekday as an offset.

The offset returned is computed based on a week that starts with Sunday and begins numbering at 0.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Thursday.to_sunday_zero_offset(), 4);

pub fn to_sunday_one_offset(self) -> i8

Returns this weekday as an offset.

The offset returned is computed based on a week that starts with Sunday and begins numbering at 1.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Thursday.to_sunday_one_offset(), 5);

pub fn next(self) -> Weekday

Returns the next weekday, wrapping around at the end of week to the beginning of the week.

This is a convenience routing for calling Weekday::wrapping_add with a value of 1.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Wednesday.next(), Weekday::Thursday);
assert_eq!(Weekday::Sunday.next(), Weekday::Monday);
assert_eq!(Weekday::Saturday.next(), Weekday::Sunday);

pub fn previous(self) -> Weekday

Returns the previous weekday, wrapping around at the beginning of week to the end of the week.

This is a convenience routing for calling Weekday::wrapping_sub with a value of 1.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Wednesday.previous(), Weekday::Tuesday);
assert_eq!(Weekday::Sunday.previous(), Weekday::Saturday);
assert_eq!(Weekday::Saturday.previous(), Weekday::Friday);

pub fn since(self, other: Weekday) -> i8

Returns the number of days from other to this weekday.

Adding the returned number of days to other is guaranteed to sum to this weekday. The number of days returned is guaranteed to be in the range 0..=6.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Friday.since(Weekday::Tuesday), 3);
assert_eq!(Weekday::Tuesday.since(Weekday::Tuesday), 0);
assert_eq!(Weekday::Monday.since(Weekday::Sunday), 1);
assert_eq!(Weekday::Sunday.since(Weekday::Monday), 6);

pub fn until(self, other: Weekday) -> i8

Returns the number of days until other from this weekday.

Adding the returned number of days to this weekday is guaranteed to sum to other weekday. The number of days returned is guaranteed to be in the range 0..=6.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Friday.until(Weekday::Tuesday), 4);
assert_eq!(Weekday::Tuesday.until(Weekday::Tuesday), 0);
assert_eq!(Weekday::Monday.until(Weekday::Sunday), 6);
assert_eq!(Weekday::Sunday.until(Weekday::Monday), 1);

pub fn wrapping_add<D>(self, days: D) -> Weekday

where D: Into<i64>,

Add the given number of days to this weekday, using wrapping arithmetic, and return the resulting weekday.

Adding a multiple of 7 (including 0) is guaranteed to produce the same weekday as this one.

Note that this routine is also available via the + operator.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Sunday.wrapping_add(1), Weekday::Monday);
assert_eq!(Weekday::Sunday.wrapping_add(2), Weekday::Tuesday);
assert_eq!(Weekday::Saturday.wrapping_add(1), Weekday::Sunday);
assert_eq!(Weekday::Saturday.wrapping_add(7), Weekday::Saturday);
assert_eq!(Weekday::Sunday.wrapping_add(-1), Weekday::Saturday);

Wrapping arithmetic is also performed by the + operator:

use jiff::civil::Weekday;

assert_eq!(Weekday::Sunday + 1, Weekday::Monday);
assert_eq!(Weekday::Sunday + 2, Weekday::Tuesday);
assert_eq!(Weekday::Saturday + 1, Weekday::Sunday);
assert_eq!(Weekday::Saturday + 7, Weekday::Saturday);
assert_eq!(Weekday::Sunday + -1, Weekday::Saturday);
// The weekday can also be on the right hand side of addition:
assert_eq!(1 + Weekday::Sunday, Weekday::Monday);

pub fn wrapping_sub<D>(self, days: D) -> Weekday

where D: Into<i64>,

Subtract the given number of days from this weekday, using wrapping arithmetic, and return the resulting weekday.

Subtracting a multiple of 7 (including 0) is guaranteed to produce the same weekday as this one.

Note that this routine is also available via the - operator.

Example

use jiff::civil::Weekday;

assert_eq!(Weekday::Sunday.wrapping_sub(1), Weekday::Saturday);
assert_eq!(Weekday::Sunday.wrapping_sub(2), Weekday::Friday);
assert_eq!(Weekday::Saturday.wrapping_sub(1), Weekday::Friday);
assert_eq!(Weekday::Saturday.wrapping_sub(7), Weekday::Saturday);
assert_eq!(Weekday::Sunday.wrapping_sub(-1), Weekday::Monday);

Wrapping arithmetic is also performed by the - operator:

use jiff::civil::Weekday;

assert_eq!(Weekday::Sunday - 1, Weekday::Saturday);
assert_eq!(Weekday::Sunday - 2, Weekday::Friday);
assert_eq!(Weekday::Saturday - 1, Weekday::Friday);
assert_eq!(Weekday::Saturday - 7, Weekday::Saturday);
assert_eq!(Weekday::Sunday - -1, Weekday::Monday);

Unlike addition, since subtraction is not commutative and negating a weekday has no semantic meaning, the weekday cannot be on the right hand side of the - operator.

pub fn cycle_forward(self) -> WeekdaysForward

Starting with this weekday, this returns an unending iterator that cycles forward through the days of the week.

Example

use jiff::civil::Weekday;

let mut it = Weekday::Tuesday.cycle_forward();
assert_eq!(it.next(), Some(Weekday::Tuesday));
assert_eq!(it.next(), Some(Weekday::Wednesday));
assert_eq!(it.next(), Some(Weekday::Thursday));
assert_eq!(it.next(), Some(Weekday::Friday));
assert_eq!(it.next(), Some(Weekday::Saturday));
assert_eq!(it.next(), Some(Weekday::Sunday));
assert_eq!(it.next(), Some(Weekday::Monday));
assert_eq!(it.next(), Some(Weekday::Tuesday));

pub fn cycle_reverse(self) -> WeekdaysReverse

Starting with this weekday, this returns an unending iterator that cycles backward through the days of the week.

Example

use jiff::civil::Weekday;

let mut it = Weekday::Tuesday.cycle_reverse();
assert_eq!(it.next(), Some(Weekday::Tuesday));
assert_eq!(it.next(), Some(Weekday::Monday));
assert_eq!(it.next(), Some(Weekday::Sunday));
assert_eq!(it.next(), Some(Weekday::Saturday));
assert_eq!(it.next(), Some(Weekday::Friday));
assert_eq!(it.next(), Some(Weekday::Thursday));
assert_eq!(it.next(), Some(Weekday::Wednesday));
assert_eq!(it.next(), Some(Weekday::Tuesday));

Trait Implementations

impl Add<Weekday> for i16

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: Weekday) -> Weekday

Performs the + operation.

impl Add<Weekday> for i32

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: Weekday) -> Weekday

Performs the + operation.

impl Add<Weekday> for i64

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: Weekday) -> Weekday

Performs the + operation.

impl Add<Weekday> for i8

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: Weekday) -> Weekday

Performs the + operation.

impl Add<i16> for Weekday

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Weekday

Performs the + operation.

impl Add<i32> for Weekday

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Weekday

Performs the + operation.

impl Add<i64> for Weekday

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Weekday

Performs the + operation.

impl Add<i8> for Weekday

type Output = Weekday

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Weekday

Performs the + operation.

impl AddAssign<i16> for Weekday

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for Weekday

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for Weekday

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for Weekday

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl Clone for Weekday

fn clone(&self) -> Weekday

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Weekday

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for Weekday

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Weekday

fn eq(&self, other: &Weekday) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<i16> for Weekday

type Output = Weekday

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Weekday

Performs the - operation.

impl Sub<i32> for Weekday

type Output = Weekday

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Weekday

Performs the - operation.

impl Sub<i64> for Weekday

type Output = Weekday

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Weekday

Performs the - operation.

impl Sub<i8> for Weekday

type Output = Weekday

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Weekday

Performs the - operation.

impl SubAssign<i16> for Weekday

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for Weekday

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for Weekday

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for Weekday

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl Copy for Weekday

impl Eq for Weekday

impl StructuralPartialEq for Weekday