devela::_dep::jiff::fmt::temporal

Struct DateTimePrinter

pub struct DateTimePrinter { /* private fields */ }
Available on crate features dep_jiff and alloc only.
Expand description

A printer for Temporal datetimes.

This printer converts an in memory representation of a datetime related type to a machine (but also human) readable format. Using this printer, one can convert Zoned, Timestamp, civil::DateTime, civil::Date or civil::Time values to a string. Note that all of those types provide Diplay implementations that utilize the default configuration of this printer. However, this printer can be configured to behave differently and can also print directly to anything that implements the fmt::Write trait.

See the fmt::temporal module documentation for more information on the specific format used. Note that the Temporal datetime parser is strictly more flexible than what is supported by this printer. For example, parsing 2024-06-15T07:00-04[America/New_York] will work just fine, even though the seconds are omitted. However, this printer provides no way to write a datetime without the second component.

§Example

This example shows how to print a Zoned value with a space separating the date and time instead of the more standard T separator.

use jiff::{civil::date, fmt::temporal::DateTimePrinter};

// A printer can be created in a const context.
const PRINTER: DateTimePrinter = DateTimePrinter::new().separator(b' ');

let zdt = date(2024, 6, 15).at(7, 0, 0, 123456789).intz("America/New_York")?;

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_zoned(&zdt, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15 07:00:00.123456789-04:00[America/New_York]");

§Example: using adapters with std::io::Write and std::fmt::Write

By using the StdIoWrite and StdFmtWrite adapters, one can print datetimes directly to implementations of std::io::Write and std::fmt::Write, respectively. The example below demonstrates writing to anything that implements std::io::Write. Similar code can be written for std::fmt::Write.

use std::{fs::File, io::{BufWriter, Write}, path::Path};

use jiff::{civil::date, fmt::{StdIoWrite, temporal::DateTimePrinter}};

let zdt = date(2024, 6, 15).at(7, 0, 0, 0).intz("America/New_York")?;

let path = Path::new("/tmp/output");
let mut file = BufWriter::new(File::create(path)?);
DateTimePrinter::new().print_zoned(&zdt, StdIoWrite(&mut file)).unwrap();
file.flush()?;
assert_eq!(
    std::fs::read_to_string(path)?,
    "2024-06-15T07:00:00-04:00[America/New_York]",
);

Implementations§

§

impl DateTimePrinter

pub const fn new() -> DateTimePrinter

Create a new Temporal datetime printer with the default configuration.

pub const fn lowercase(self, yes: bool) -> DateTimePrinter

Use lowercase for the datetime separator and the Z (Zulu) UTC offset.

This is disabled by default.

§Example

This example shows how to print a Zoned value with a lowercase datetime separator.

use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new().lowercase(true);

let zdt = date(2024, 6, 15).at(7, 0, 0, 0).intz("America/New_York")?;

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_zoned(&zdt, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15t07:00:00-04:00[America/New_York]");

pub const fn separator(self, ascii_char: u8) -> DateTimePrinter

Use the given ASCII character to separate the date and time when printing Zoned, Timestamp or civil::DateTime values.

This is set to T by default.

§Example

This example shows how to print a Zoned value with a different datetime separator.

use jiff::{civil::date, fmt::temporal::DateTimePrinter};

// We use a weird non-standard character here, but typically one would
// use this method with an ASCII space.
const PRINTER: DateTimePrinter = DateTimePrinter::new().separator(b'~');

let zdt = date(2024, 6, 15).at(7, 0, 0, 0).intz("America/New_York")?;

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_zoned(&zdt, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15~07:00:00-04:00[America/New_York]");

pub const fn precision(self, precision: Option<u8>) -> DateTimePrinter

Set the precision to use for formatting the fractional second component of a time.

The default is None, which will automatically set the precision based on the value.

When the precision is set to N, you’ll always get precisely N digits after a decimal point (unless N==0, then no fractional component is printed), even if they are 0.

§Example
use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter =
    DateTimePrinter::new().precision(Some(3));

let zdt = date(2024, 6, 15).at(7, 0, 0, 123_456_789).intz("US/Eastern")?;

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_zoned(&zdt, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15T07:00:00.123-04:00[US/Eastern]");
§Example: available via formatting machinery

When formatting datetime types that may contain a fractional second component, this can be set via Rust’s formatting DSL. Specifically, it corresponds to the std::fmt::Formatter::precision setting.

use jiff::civil::date;

let zdt = date(2024, 6, 15).at(7, 0, 0, 123_000_000).intz("US/Eastern")?;
assert_eq!(
    format!("{zdt:.6}"),
    "2024-06-15T07:00:00.123000-04:00[US/Eastern]",
);
// Precision values greater than 9 are clamped to 9.
assert_eq!(
    format!("{zdt:.300}"),
    "2024-06-15T07:00:00.123000000-04:00[US/Eastern]",
);
// A precision of 0 implies the entire fractional
// component is always truncated.
assert_eq!(
    format!("{zdt:.0}"),
    "2024-06-15T07:00:00-04:00[US/Eastern]",
);

pub fn zoned_to_string(&self, zdt: &Zoned) -> String ⓘ

Format a Zoned datetime into a string.

This is a convenience routine for DateTimePrinter::print_zoned with a String.

§Example
use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let zdt = date(2024, 6, 15).at(7, 0, 0, 0).intz("America/New_York")?;
assert_eq!(
    PRINTER.zoned_to_string(&zdt),
    "2024-06-15T07:00:00-04:00[America/New_York]",
);

pub fn timestamp_to_string(&self, timestamp: &Timestamp) -> String ⓘ

Format a Timestamp datetime into a string.

This will always return an RFC 3339 compatible string with a Z or Zulu offset. Zulu is chosen in accordance with RFC 9557’s update to RFC 3339 that establishes the -00:00 offset as equivalent to Zulu:

If the time in UTC is known, but the offset to local time is unknown, this can be represented with an offset of “Z”. (The original version of this specification provided -00:00 for this purpose, which is not allowed by ISO8601:2000 and therefore is less interoperable; Section 3.3 of RFC5322 describes a related convention for email, which does not have this problem). This differs semantically from an offset of +00:00, which implies that UTC is the preferred reference point for the specified time.

In other words, both Zulu time and -00:00 mean “the time in UTC is known, but the offset to local time is unknown.”

If you need to format an RFC 3339 timestamp with a specific offset, use DateTimePrinter::timestamp_with_offset_to_string.

This is a convenience routine for DateTimePrinter::print_timestamp with a String.

§Example
use jiff::{fmt::temporal::DateTimePrinter, Timestamp};

let timestamp = Timestamp::new(0, 1)
    .expect("one nanosecond after Unix epoch is always valid");
assert_eq!(
    DateTimePrinter::new().timestamp_to_string(&timestamp),
    "1970-01-01T00:00:00.000000001Z",
);

pub fn timestamp_with_offset_to_string( &self, timestamp: &Timestamp, offset: Offset, ) -> String ⓘ

Format a Timestamp datetime into a string with the given offset.

This will always return an RFC 3339 compatible string with an offset.

This will never use either Z (for Zulu time) or -00:00 as an offset. This is because Zulu time (and -00:00) mean “the time in UTC is known, but the offset to local time is unknown.” Since this routine accepts an explicit offset, the offset is known. For example, Offset::UTC will be formatted as +00:00.

To format an RFC 3339 string in Zulu time, use DateTimePrinter::timestamp_to_string.

This is a convenience routine for DateTimePrinter::print_timestamp_with_offset with a String.

§Example
use jiff::{fmt::temporal::DateTimePrinter, tz, Timestamp};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let timestamp = Timestamp::new(0, 1)
    .expect("one nanosecond after Unix epoch is always valid");
assert_eq!(
    PRINTER.timestamp_with_offset_to_string(&timestamp, tz::offset(-5)),
    "1969-12-31T19:00:00.000000001-05:00",
);
§Example: Offset::UTC formats as +00:00
use jiff::{fmt::temporal::DateTimePrinter, tz::Offset, Timestamp};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let timestamp = Timestamp::new(0, 1)
    .expect("one nanosecond after Unix epoch is always valid");
assert_eq!(
    PRINTER.timestamp_with_offset_to_string(&timestamp, Offset::UTC),
    "1970-01-01T00:00:00.000000001+00:00",
);

pub fn datetime_to_string(&self, dt: &DateTime) -> String ⓘ

Format a civil::DateTime into a string.

This is a convenience routine for DateTimePrinter::print_datetime with a String.

§Example
use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let dt = date(2024, 6, 15).at(7, 0, 0, 0);
assert_eq!(PRINTER.datetime_to_string(&dt), "2024-06-15T07:00:00");

pub fn date_to_string(&self, date: &Date) -> String ⓘ

Format a civil::Date into a string.

This is a convenience routine for DateTimePrinter::print_date with a String.

§Example
use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let d = date(2024, 6, 15);
assert_eq!(PRINTER.date_to_string(&d), "2024-06-15");

pub fn time_to_string(&self, time: &Time) -> String ⓘ

Format a civil::Time into a string.

This is a convenience routine for DateTimePrinter::print_time with a String.

§Example
use jiff::{civil::time, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let t = time(7, 0, 0, 0);
assert_eq!(PRINTER.time_to_string(&t), "07:00:00");

pub fn pieces_to_string(&self, pieces: &Pieces<'_>) -> String ⓘ

Format Pieces of a Temporal datetime.

This is a convenience routine for DateTimePrinter::print_pieces with a String.

§Example
use jiff::{
    fmt::temporal::{DateTimePrinter, Pieces},
    tz::offset,
    Timestamp,
};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let pieces = Pieces::from(Timestamp::UNIX_EPOCH);
assert_eq!(
    PRINTER.pieces_to_string(&pieces),
    "1970-01-01T00:00:00Z",
);

let pieces = Pieces::from((Timestamp::UNIX_EPOCH, offset(0)));
assert_eq!(
    PRINTER.pieces_to_string(&pieces),
    "1970-01-01T00:00:00+00:00",
);

let pieces = Pieces::from((Timestamp::UNIX_EPOCH, offset(-5)));
assert_eq!(
    PRINTER.pieces_to_string(&pieces),
    "1969-12-31T19:00:00-05:00",
);

pub fn print_zoned<W>(&self, zdt: &Zoned, wtr: W) -> Result<(), Error> ⓘ
where W: Write,

Print a Zoned datetime to the given writer.

§Errors

This only returns an error when writing to the given Write implementation would fail. Some such implementations, like for String and Vec<u8>, never fail (unless memory allocation fails). In such cases, it would be appropriate to call unwrap() on the result.

§Example
use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let zdt = date(2024, 6, 15).at(7, 0, 0, 0).intz("America/New_York")?;

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_zoned(&zdt, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15T07:00:00-04:00[America/New_York]");

pub fn print_timestamp<W>( &self, timestamp: &Timestamp, wtr: W, ) -> Result<(), Error> ⓘ
where W: Write,

Print a Timestamp datetime to the given writer.

This will always write an RFC 3339 compatible string with a Z or Zulu offset. Zulu is chosen in accordance with RFC 9557’s update to RFC 3339 that establishes the -00:00 offset as equivalent to Zulu:

If the time in UTC is known, but the offset to local time is unknown, this can be represented with an offset of “Z”. (The original version of this specification provided -00:00 for this purpose, which is not allowed by ISO8601:2000 and therefore is less interoperable; Section 3.3 of RFC5322 describes a related convention for email, which does not have this problem). This differs semantically from an offset of +00:00, which implies that UTC is the preferred reference point for the specified time.

In other words, both Zulu time and -00:00 mean “the time in UTC is known, but the offset to local time is unknown.”

If you need to write an RFC 3339 timestamp with a specific offset, use DateTimePrinter::print_timestamp_with_offset.

§Errors

This only returns an error when writing to the given Write implementation would fail. Some such implementations, like for String and Vec<u8>, never fail (unless memory allocation fails). In such cases, it would be appropriate to call unwrap() on the result.

§Example
use jiff::{fmt::temporal::DateTimePrinter, Timestamp};

let timestamp = Timestamp::new(0, 1)
    .expect("one nanosecond after Unix epoch is always valid");

let mut buf = String::new();
// Printing to a `String` can never fail.
DateTimePrinter::new().print_timestamp(&timestamp, &mut buf).unwrap();
assert_eq!(buf, "1970-01-01T00:00:00.000000001Z");

pub fn print_timestamp_with_offset<W>( &self, timestamp: &Timestamp, offset: Offset, wtr: W, ) -> Result<(), Error> ⓘ
where W: Write,

Print a Timestamp datetime to the given writer with the given offset.

This will always write an RFC 3339 compatible string with an offset.

This will never write either Z (for Zulu time) or -00:00 as an offset. This is because Zulu time (and -00:00) mean “the time in UTC is known, but the offset to local time is unknown.” Since this routine accepts an explicit offset, the offset is known. For example, Offset::UTC will be formatted as +00:00.

To write an RFC 3339 string in Zulu time, use DateTimePrinter::print_timestamp.

§Errors

This only returns an error when writing to the given Write implementation would fail. Some such implementations, like for String and Vec<u8>, never fail (unless memory allocation fails). In such cases, it would be appropriate to call unwrap() on the result.

§Example
use jiff::{fmt::temporal::DateTimePrinter, tz, Timestamp};

let timestamp = Timestamp::new(0, 1)
    .expect("one nanosecond after Unix epoch is always valid");

let mut buf = String::new();
// Printing to a `String` can never fail.
DateTimePrinter::new().print_timestamp_with_offset(
    &timestamp,
    tz::offset(-5),
    &mut buf,
).unwrap();
assert_eq!(buf, "1969-12-31T19:00:00.000000001-05:00");
§Example: Offset::UTC formats as +00:00
use jiff::{fmt::temporal::DateTimePrinter, tz::Offset, Timestamp};

let timestamp = Timestamp::new(0, 1)
    .expect("one nanosecond after Unix epoch is always valid");

let mut buf = String::new();
// Printing to a `String` can never fail.
DateTimePrinter::new().print_timestamp_with_offset(
    &timestamp,
    Offset::UTC, // equivalent to `Offset::from_hours(0)`
    &mut buf,
).unwrap();
assert_eq!(buf, "1970-01-01T00:00:00.000000001+00:00");

pub fn print_datetime<W>(&self, dt: &DateTime, wtr: W) -> Result<(), Error> ⓘ
where W: Write,

Print a civil::DateTime to the given writer.

§Errors

This only returns an error when writing to the given Write implementation would fail. Some such implementations, like for String and Vec<u8>, never fail (unless memory allocation fails). In such cases, it would be appropriate to call unwrap() on the result.

§Example
use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let d = date(2024, 6, 15).at(7, 0, 0, 0);

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_datetime(&d, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15T07:00:00");

pub fn print_date<W>(&self, date: &Date, wtr: W) -> Result<(), Error> ⓘ
where W: Write,

Print a civil::Date to the given writer.

§Errors

This only returns an error when writing to the given Write implementation would fail. Some such implementations, like for String and Vec<u8>, never fail (unless memory allocation fails). In such cases, it would be appropriate to call unwrap() on the result.

§Example
use jiff::{civil::date, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let d = date(2024, 6, 15);

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_date(&d, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15");

pub fn print_time<W>(&self, time: &Time, wtr: W) -> Result<(), Error> ⓘ
where W: Write,

Print a civil::Time to the given writer.

§Errors

This only returns an error when writing to the given Write implementation would fail. Some such implementations, like for String and Vec<u8>, never fail (unless memory allocation fails). In such cases, it would be appropriate to call unwrap() on the result.

§Example
use jiff::{civil::time, fmt::temporal::DateTimePrinter};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let t = time(7, 0, 0, 0);

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_time(&t, &mut buf).unwrap();
assert_eq!(buf, "07:00:00");

pub fn print_pieces<W>(&self, pieces: &Pieces<'_>, wtr: W) -> Result<(), Error> ⓘ
where W: Write,

Print the Pieces of a Temporal datetime.

§Errors

This only returns an error when writing to the given Write implementation would fail. Some such implementations, like for String and Vec<u8>, never fail (unless memory allocation fails). In such cases, it would be appropriate to call unwrap() on the result.

§Example
use jiff::{civil::date, fmt::temporal::{DateTimePrinter, Pieces}};

const PRINTER: DateTimePrinter = DateTimePrinter::new();

let pieces = Pieces::from(date(2024, 6, 15))
    .with_time_zone_name("US/Eastern");

let mut buf = String::new();
// Printing to a `String` can never fail.
PRINTER.print_pieces(&pieces, &mut buf).unwrap();
assert_eq!(buf, "2024-06-15[US/Eastern]");

Trait Implementations§

§

impl Debug for DateTimePrinter

§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> ArchivePointee for T

§

type ArchivedMetadata = ()

The archived version of the pointer metadata for this type.
§

fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata, ) -> <T as Pointee>::Metadata

Converts some archived metadata to the pointer metadata for itself.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> ByteSized for T

Source§

const BYTE_ALIGN: usize = _

The alignment of this type in bytes.
Source§

const BYTE_SIZE: usize = _

The size of this type in bytes.
Source§

fn byte_align(&self) -> usize ⓘ

Returns the alignment of this type in bytes.
Source§

fn byte_size(&self) -> usize ⓘ

Returns the size of this type in bytes. Read more
Source§

fn ptr_size_ratio(&self) -> [usize; 2]

Returns the size ratio between Ptr::BYTES and BYTE_SIZE. Read more
Source§

impl<T, R> Chain<R> for T
where T: ?Sized,

Source§

fn chain<F>(self, f: F) -> R
where F: FnOnce(Self) -> R, Self: Sized,

Chain a function which takes the parameter by value.
Source§

fn chain_ref<F>(&self, f: F) -> R
where F: FnOnce(&Self) -> R,

Chain a function which takes the parameter by shared reference.
Source§

fn chain_mut<F>(&mut self, f: F) -> R
where F: FnOnce(&mut Self) -> R,

Chain a function which takes the parameter by exclusive reference.
Source§

impl<T> ExtAny for T
where T: Any + ?Sized,

Source§

fn type_id() -> TypeId

Returns the TypeId of Self. Read more
Source§

fn type_of(&self) -> TypeId

Returns the TypeId of self. Read more
Source§

fn type_name(&self) -> &'static str ⓘ

Returns the type name of self. Read more
Source§

fn type_is<T: 'static>(&self) -> bool

Returns true if Self is of type T. Read more
Source§

fn as_any_ref(&self) -> &dyn Any
where Self: Sized,

Upcasts &self as &dyn Any. Read more
Source§

fn as_any_mut(&mut self) -> &mut dyn Any
where Self: Sized,

Upcasts &mut self as &mut dyn Any. Read more
Source§

fn as_any_box(self: Box<Self>) -> Box<dyn Any>
where Self: Sized,

Upcasts Box<self> as Box<dyn Any>. Read more
Source§

fn downcast_ref<T: 'static>(&self) -> Option<&T> ⓘ

Available on crate feature unsafe_layout only.
Returns some shared reference to the inner value if it is of type T. Read more
Source§

fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> ⓘ

Available on crate feature unsafe_layout only.
Returns some exclusive reference to the inner value if it is of type T. Read more
Source§

impl<T> ExtMem for T
where T: ?Sized,

Source§

const NEEDS_DROP: bool = _

Know whether dropping values of this type matters, in compile-time.
Source§

fn mem_align_of<T>() -> usize ⓘ

Returns the minimum alignment of the type in bytes. Read more
Source§

fn mem_align_of_val(&self) -> usize ⓘ

Returns the alignment of the pointed-to value in bytes. Read more
Source§

fn mem_size_of<T>() -> usize ⓘ

Returns the size of a type in bytes. Read more
Source§

fn mem_size_of_val(&self) -> usize ⓘ

Returns the size of the pointed-to value in bytes. Read more
Source§

fn mem_copy(&self) -> Self
where Self: Copy,

Bitwise-copies a value. Read more
Source§

fn mem_needs_drop(&self) -> bool

Returns true if dropping values of this type matters. Read more
Source§

fn mem_drop(self)
where Self: Sized,

Drops self by running its destructor. Read more
Source§

fn mem_forget(self)
where Self: Sized,

Forgets about self without running its destructor. Read more
Source§

fn mem_replace(&mut self, other: Self) -> Self
where Self: Sized,

Replaces self with other, returning the previous value of self. Read more
Source§

fn mem_take(&mut self) -> Self
where Self: Default,

Replaces self with its default value, returning the previous value of self. Read more
Source§

fn mem_swap(&mut self, other: &mut Self)
where Self: Sized,

Swaps the value of self and other without deinitializing either one. Read more
Source§

unsafe fn mem_zeroed<T>() -> T

Available on crate feature unsafe_layout only.
Returns the value of type T represented by the all-zero byte-pattern. Read more
Source§

unsafe fn mem_transmute_copy<Src, Dst>(src: &Src) -> Dst

Available on crate feature unsafe_layout only.
Returns the value of type T represented by the all-zero byte-pattern. Read more
Source§

fn mem_as_bytes(&self) -> &[u8] ⓘ
where Self: Sync + Unpin,

Available on crate feature unsafe_slice only.
View a Sync + Unpin self as &[u8]. Read more
Source§

fn mem_as_bytes_mut(&mut self) -> &mut [u8] ⓘ
where Self: Sync + Unpin,

Available on crate feature unsafe_slice only.
View a Sync + Unpin self as &mut [u8]. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<S> FromSample<S> for S

§

fn from_sample_(s: S) -> S

Source§

impl<T> Hook for T

Source§

fn hook_ref<F>(self, f: F) -> Self
where F: FnOnce(&Self),

Applies a function which takes the parameter by shared reference, and then returns the (possibly) modified owned value. Read more
Source§

fn hook_mut<F>(self, f: F) -> Self
where F: FnOnce(&mut Self),

Applies a function which takes the parameter by exclusive reference, and then returns the (possibly) modified owned value. Read more
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

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

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

§

fn into_sample(self) -> T

§

impl<T> LayoutRaw for T

§

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError> ⓘ

Returns the layout of the type.
§

impl<T, N1, N2> Niching<NichedOption<T, N1>> for N2
where T: SharedNiching<N1, N2>, N1: Niching<T>, N2: Niching<T>,

§

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

Returns whether the given value has been niched. Read more
§

fn resolve_niched(out: Place<NichedOption<T, N1>>)

Writes data to out indicating that a T is niched.
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize ⓘ

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> Pointee for T

§

type Metadata = ()

The metadata type for pointers and references to this type.
§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

§

fn to_sample_(self) -> U

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

§

impl<T> Ungil for T
where T: Send,