Enum `Weekday`

enum Weekday

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
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

Implementations

`impl Weekday`

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());

# Ok::<(), Box<dyn std::error::Error>>(())

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());

# Ok::<(), Box<dyn std::error::Error>>(())

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());

# Ok::<(), Box<dyn std::error::Error>>(())

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());

# Ok::<(), Box<dyn std::error::Error>>(())

fn to_monday_zero_offset(self: 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);

# Ok::<(), Box<dyn std::error::Error>>(())

fn to_monday_one_offset(self: 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);

# Ok::<(), Box<dyn std::error::Error>>(())

fn to_sunday_zero_offset(self: 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);

# Ok::<(), Box<dyn std::error::Error>>(())

fn to_sunday_one_offset(self: 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);

# Ok::<(), Box<dyn std::error::Error>>(())

fn next(self: 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);

fn previous(self: 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);

fn since(self: 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);

fn until(self: 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);

fn wrapping_add<D: Into<i64>>(self: Self, days: D) -> Weekday

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);

fn wrapping_sub<D: Into<i64>>(self: Self, days: D) -> Weekday

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.

fn cycle_forward(self: 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));

fn cycle_reverse(self: 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));

`impl Add for Weekday`

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

`impl Add for Weekday`

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

`impl Add for Weekday`

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

`impl Add for Weekday`

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

`impl AddAssign for Weekday`

fn add_assign(self: &mut Self, rhs: i64)

`impl AddAssign for Weekday`

fn add_assign(self: &mut Self, rhs: i8)

`impl AddAssign for Weekday`

fn add_assign(self: &mut Self, rhs: i16)

`impl AddAssign for Weekday`

fn add_assign(self: &mut Self, rhs: i32)

`impl Clone for Weekday`

fn clone(self: &Self) -> Weekday

`impl Copy for Weekday`

`impl Debug for Weekday`

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

`impl Eq for Weekday`

`impl Freeze for Weekday`

`impl Hash for Weekday`

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

`impl PartialEq for Weekday`

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

`impl RefUnwindSafe for Weekday`

`impl Send for Weekday`

`impl StructuralPartialEq for Weekday`

`impl Sub for Weekday`

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

`impl Sub for Weekday`

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

`impl Sub for Weekday`

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

`impl Sub for Weekday`

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

`impl SubAssign for Weekday`

fn sub_assign(self: &mut Self, rhs: i64)

`impl SubAssign for Weekday`

fn sub_assign(self: &mut Self, rhs: i8)

`impl SubAssign for Weekday`

fn sub_assign(self: &mut Self, rhs: i16)

`impl SubAssign for Weekday`

fn sub_assign(self: &mut Self, rhs: i32)

`impl Sync for Weekday`

`impl Unpin for Weekday`

`impl UnsafeUnpin for Weekday`

`impl UnwindSafe for Weekday`

`impl<T> Any for Weekday`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Weekday`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Weekday`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Weekday`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Weekday`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Weekday`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Weekday`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Weekday`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Weekday`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>