# Struct chrono::Duration [−] [src]

    pub struct Duration { /* fields omitted */ }

ISO 8601 time duration with nanosecond precision. This also allows for the negative duration; see individual methods for details.

## Implementations

### `impl Duration` [src]

#### `pub fn weeks(weeks: i64) -> Duration` [src]

Makes a new `Duration` with given number of weeks. Equivalent to `Duration::seconds(weeks * 7 * 24 * 60 * 60)` with overflow checks. Panics when the duration is out of bounds.

#### `pub fn days(days: i64) -> Duration` [src]

Makes a new `Duration` with given number of days. Equivalent to `Duration::seconds(days * 24 * 60 * 60)` with overflow checks. Panics when the duration is out of bounds.

#### `pub fn hours(hours: i64) -> Duration` [src]

Makes a new `Duration` with given number of hours. Equivalent to `Duration::seconds(hours * 60 * 60)` with overflow checks. Panics when the duration is out of bounds.

#### `pub fn minutes(minutes: i64) -> Duration` [src]

Makes a new `Duration` with given number of minutes. Equivalent to `Duration::seconds(minutes * 60)` with overflow checks. Panics when the duration is out of bounds.

#### `pub fn seconds(seconds: i64) -> Duration` [src]

Makes a new `Duration` with given number of seconds. Panics when the duration is more than `i64::MAX` milliseconds or less than `i64::MIN` milliseconds.

#### `pub fn milliseconds(milliseconds: i64) -> Duration` [src]

Makes a new `Duration` with given number of milliseconds.

#### `pub fn microseconds(microseconds: i64) -> Duration` [src]

Makes a new `Duration` with given number of microseconds.

#### `pub fn nanoseconds(nanos: i64) -> Duration` [src]

Makes a new `Duration` with given number of nanoseconds.

#### `pub fn span<F>(f: F) -> Duration where
F: FnOnce(),` [src]

Runs a closure, returning the duration of time it took to run the closure.

#### `pub fn num_weeks(&self) -> i64` [src]

Returns the total number of whole weeks in the duration.

#### `pub fn num_days(&self) -> i64` [src]

Returns the total number of whole days in the duration.

#### `pub fn num_hours(&self) -> i64` [src]

Returns the total number of whole hours in the duration.

#### `pub fn num_minutes(&self) -> i64` [src]

Returns the total number of whole minutes in the duration.

#### `pub fn num_seconds(&self) -> i64` [src]

Returns the total number of whole seconds in the duration.

#### `pub fn num_milliseconds(&self) -> i64` [src]

Returns the total number of whole milliseconds in the duration,

#### `pub fn num_microseconds(&self) -> Option<i64>` [src]

Returns the total number of whole microseconds in the duration, or `None` on overflow (exceeding 263 microseconds in either direction).

#### `pub fn num_nanoseconds(&self) -> Option<i64>` [src]

Returns the total number of whole nanoseconds in the duration, or `None` on overflow (exceeding 263 nanoseconds in either direction).

#### `pub fn checked_add(&self, rhs: &Duration) -> Option<Duration>` [src]

Add two durations, returning `None` if overflow occurred.

#### `pub fn checked_sub(&self, rhs: &Duration) -> Option<Duration>` [src]

Subtract two durations, returning `None` if overflow occurred.

#### `pub fn min_value() -> Duration` [src]

The minimum possible `Duration`: `i64::MIN` milliseconds.

#### `pub fn max_value() -> Duration` [src]

The maximum possible `Duration`: `i64::MAX` milliseconds.

#### `pub fn zero() -> Duration` [src]

A duration where the stored seconds and nanoseconds are equal to zero.

#### `pub fn is_zero(&self) -> bool` [src]

Returns `true` if the duration equals `Duration::zero()`.

#### `pub fn from_std(duration: Duration) -> Result<Duration, OutOfRangeError>` [src]

Creates a `time::Duration` object from `std::time::Duration`

This function errors when original duration is larger than the maximum value supported for this type.

#### `pub fn to_std(&self) -> Result<Duration, OutOfRangeError>` [src]

Creates a `std::time::Duration` object from `time::Duration`

This function errors when duration is less than zero. As standard library implementation is limited to non-negative values.

## Trait Implementations

### `impl Add<Duration> for Duration` [src]

#### `type Output = Duration`

The resulting type after applying the `+` operator.

#### `pub fn add(self, rhs: Duration) -> Duration` [src]

Performs the `+` operation. Read more

### `impl Add<Duration> for NaiveDate` [src]

An addition of `Duration` to `NaiveDate` discards the fractional days, rounding to the closest integral number of days towards `Duration::zero()`.

Panics on underflow or overflow. Use `NaiveDate::checked_add_signed` to detect that.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    assert_eq!(from_ymd(2014, 1, 1) + Duration::zero(),             from_ymd(2014, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(86399),     from_ymd(2014, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(-86399),    from_ymd(2014, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) + Duration::days(1),            from_ymd(2014, 1, 2));
    assert_eq!(from_ymd(2014, 1, 1) + Duration::days(-1),           from_ymd(2013, 12, 31));
    assert_eq!(from_ymd(2014, 1, 1) + Duration::days(364),          from_ymd(2014, 12, 31));
    assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*4 + 1),    from_ymd(2018, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*400 + 97), from_ymd(2414, 1, 1));

#### `type Output = NaiveDate`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: OldDuration) -> NaiveDate` [src]

Performs the `+` operation. Read more

### `impl Add<Duration> for NaiveDateTime` [src]

An addition of `Duration` to `NaiveDateTime` yields another `NaiveDateTime`.

As a part of Chrono’s leap second handling, the addition assumes that there is no leap second ever, except when the `NaiveDateTime` itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

Panics on underflow or overflow. Use `NaiveDateTime::checked_add_signed` to detect that.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    let hms = |h, m, s| d.and_hms(h, m, s);
    assert_eq!(hms(3, 5, 7) + Duration::zero(),             hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(1),         hms(3, 5, 8));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(-1),        hms(3, 5, 6));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(3600 + 60), hms(4, 6, 7));
    assert_eq!(hms(3, 5, 7) + Duration::seconds(86_400),
               from_ymd(2016, 7, 9).and_hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) + Duration::days(365),
               from_ymd(2017, 7, 8).and_hms(3, 5, 7));

    let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
    assert_eq!(hmsm(3, 5, 7, 980) + Duration::milliseconds(450), hmsm(3, 5, 8, 430));

Leap seconds are handled, but the addition assumes that it is the only leap second happened.

    let leap = hmsm(3, 5, 59, 1_300);
    assert_eq!(leap + Duration::zero(),             hmsm(3, 5, 59, 1_300));
    assert_eq!(leap + Duration::milliseconds(-500), hmsm(3, 5, 59, 800));
    assert_eq!(leap + Duration::milliseconds(500),  hmsm(3, 5, 59, 1_800));
    assert_eq!(leap + Duration::milliseconds(800),  hmsm(3, 6, 0, 100));
    assert_eq!(leap + Duration::seconds(10),        hmsm(3, 6, 9, 300));
    assert_eq!(leap + Duration::seconds(-10),       hmsm(3, 5, 50, 300));
    assert_eq!(leap + Duration::days(1),
               from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300));

#### `type Output = NaiveDateTime`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: OldDuration) -> NaiveDateTime` [src]

Performs the `+` operation. Read more

### `impl Add<Duration> for NaiveTime` [src]

An addition of `Duration` to `NaiveTime` wraps around and never overflows or underflows. In particular the addition ignores integral number of days.

As a part of Chrono’s leap second handling, the addition assumes that there is no leap second ever, except when the `NaiveTime` itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

# Example

    use chrono::{Duration, NaiveTime};

    let from_hmsm = NaiveTime::from_hms_milli;

    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::zero(),                  from_hmsm(3, 5, 7, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(1),              from_hmsm(3, 5, 8, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-1),             from_hmsm(3, 5, 6, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(60 + 4),         from_hmsm(3, 6, 11, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(7*60*60 - 6*60), from_hmsm(9, 59, 7, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::milliseconds(80),        from_hmsm(3, 5, 7, 80));
    assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(280),     from_hmsm(3, 5, 8, 230));
    assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(-980),    from_hmsm(3, 5, 6, 970));

The addition wraps around.

    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(22*60*60), from_hmsm(1, 5, 7, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-8*60*60), from_hmsm(19, 5, 7, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::days(800),         from_hmsm(3, 5, 7, 0));

Leap seconds are handled, but the addition assumes that it is the only leap second happened.

    let leap = from_hmsm(3, 5, 59, 1_300);
    assert_eq!(leap + Duration::zero(),             from_hmsm(3, 5, 59, 1_300));
    assert_eq!(leap + Duration::milliseconds(-500), from_hmsm(3, 5, 59, 800));
    assert_eq!(leap + Duration::milliseconds(500),  from_hmsm(3, 5, 59, 1_800));
    assert_eq!(leap + Duration::milliseconds(800),  from_hmsm(3, 6, 0, 100));
    assert_eq!(leap + Duration::seconds(10),        from_hmsm(3, 6, 9, 300));
    assert_eq!(leap + Duration::seconds(-10),       from_hmsm(3, 5, 50, 300));
    assert_eq!(leap + Duration::days(1),            from_hmsm(3, 5, 59, 300));

#### `type Output = NaiveTime`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: OldDuration) -> NaiveTime` [src]

Performs the `+` operation. Read more

### `impl<Tz: TimeZone> Add<Duration> for Date<Tz>` [src]

#### `type Output = Date<Tz>`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: OldDuration) -> Date<Tz>` [src]

Performs the `+` operation. Read more

### `impl<Tz: TimeZone> Add<Duration> for DateTime<Tz>` [src]

#### `type Output = DateTime<Tz>`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: OldDuration) -> DateTime<Tz>` [src]

Performs the `+` operation. Read more

### `impl AddAssign<Duration> for NaiveDate` [src]

#### `fn add_assign(&mut self, rhs: OldDuration)` [src]

Performs the `+=` operation. Read more

### `impl AddAssign<Duration> for NaiveDateTime` [src]

#### `fn add_assign(&mut self, rhs: OldDuration)` [src]

Performs the `+=` operation. Read more

### `impl AddAssign<Duration> for NaiveTime` [src]

#### `fn add_assign(&mut self, rhs: OldDuration)` [src]

Performs the `+=` operation. Read more

### `impl Clone for Duration` [src]

#### `pub fn clone(&self) -> Duration` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Copy for Duration` [src]

### `impl Debug for Duration` [src]

#### `pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl Display for Duration` [src]

#### `pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl Div<i32> for Duration` [src]

#### `type Output = Duration`

The resulting type after applying the `/` operator.

#### `pub fn div(self, rhs: i32) -> Duration` [src]

Performs the `/` operation. Read more

### `impl Eq for Duration` [src]

### `impl Hash for Duration` [src]

#### `pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,` [src]

Feeds this value into the given `Hasher`. Read more

#### `pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0 [src]

Feeds a slice of this type into the given `Hasher`. Read more

### `impl Mul<i32> for Duration` [src]

#### `type Output = Duration`

The resulting type after applying the `*` operator.

#### `pub fn mul(self, rhs: i32) -> Duration` [src]

Performs the `*` operation. Read more

### `impl Neg for Duration` [src]

#### `type Output = Duration`

The resulting type after applying the `-` operator.

#### `pub fn neg(self) -> Duration` [src]

Performs the unary `-` operation. Read more

### `impl Ord for Duration` [src]

#### `pub fn cmp(&self, other: &Duration) -> Ordering` [src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `#[must_use]pub fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]pub fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self` 1.50.0 [src]

Restrict a value to a certain interval. Read more

### `impl PartialEq<Duration> for Duration` [src]

#### `pub fn eq(&self, other: &Duration) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `pub fn ne(&self, other: &Duration) -> bool` [src]

This method tests for `!=`.

### `impl PartialOrd<Duration> for Duration` [src]

#### `pub fn partial_cmp(&self, other: &Duration) -> Option<Ordering>` [src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use]pub fn lt(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use]pub fn le(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use]pub fn gt(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use]pub fn ge(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl StructuralEq for Duration` [src]

### `impl StructuralPartialEq for Duration` [src]

### `impl Sub<Duration> for Duration` [src]

#### `type Output = Duration`

The resulting type after applying the `-` operator.

#### `pub fn sub(self, rhs: Duration) -> Duration` [src]

Performs the `-` operation. Read more

### `impl Sub<Duration> for NaiveDate` [src]

A subtraction of `Duration` from `NaiveDate` discards the fractional days, rounding to the closest integral number of days towards `Duration::zero()`. It is the same as the addition with a negated `Duration`.

Panics on underflow or overflow. Use `NaiveDate::checked_sub_signed` to detect that.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    assert_eq!(from_ymd(2014, 1, 1) - Duration::zero(),             from_ymd(2014, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(86399),     from_ymd(2014, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(-86399),    from_ymd(2014, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) - Duration::days(1),            from_ymd(2013, 12, 31));
    assert_eq!(from_ymd(2014, 1, 1) - Duration::days(-1),           from_ymd(2014, 1, 2));
    assert_eq!(from_ymd(2014, 1, 1) - Duration::days(364),          from_ymd(2013, 1, 2));
    assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*4 + 1),    from_ymd(2010, 1, 1));
    assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*400 + 97), from_ymd(1614, 1, 1));

#### `type Output = NaiveDate`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: OldDuration) -> NaiveDate` [src]

Performs the `-` operation. Read more

### `impl Sub<Duration> for NaiveDateTime` [src]

A subtraction of `Duration` from `NaiveDateTime` yields another `NaiveDateTime`. It is the same as the addition with a negated `Duration`.

As a part of Chrono’s leap second handling, the addition assumes that there is no leap second ever, except when the `NaiveDateTime` itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

Panics on underflow or overflow. Use `NaiveDateTime::checked_sub_signed` to detect that.

# Example

    use chrono::{Duration, NaiveDate};

    let from_ymd = NaiveDate::from_ymd;

    let d = from_ymd(2016, 7, 8);
    let hms = |h, m, s| d.and_hms(h, m, s);
    assert_eq!(hms(3, 5, 7) - Duration::zero(),             hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(1),         hms(3, 5, 6));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(-1),        hms(3, 5, 8));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(3600 + 60), hms(2, 4, 7));
    assert_eq!(hms(3, 5, 7) - Duration::seconds(86_400),
               from_ymd(2016, 7, 7).and_hms(3, 5, 7));
    assert_eq!(hms(3, 5, 7) - Duration::days(365),
               from_ymd(2015, 7, 9).and_hms(3, 5, 7));

    let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
    assert_eq!(hmsm(3, 5, 7, 450) - Duration::milliseconds(670), hmsm(3, 5, 6, 780));

Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.

    let leap = hmsm(3, 5, 59, 1_300);
    assert_eq!(leap - Duration::zero(),            hmsm(3, 5, 59, 1_300));
    assert_eq!(leap - Duration::milliseconds(200), hmsm(3, 5, 59, 1_100));
    assert_eq!(leap - Duration::milliseconds(500), hmsm(3, 5, 59, 800));
    assert_eq!(leap - Duration::seconds(60),       hmsm(3, 5, 0, 300));
    assert_eq!(leap - Duration::days(1),
               from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300));

#### `type Output = NaiveDateTime`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: OldDuration) -> NaiveDateTime` [src]

Performs the `-` operation. Read more

### `impl Sub<Duration> for NaiveTime` [src]

A subtraction of `Duration` from `NaiveTime` wraps around and never overflows or underflows. In particular the addition ignores integral number of days. It is the same as the addition with a negated `Duration`.

As a part of Chrono’s leap second handling, the addition assumes that there is no leap second ever, except when the `NaiveTime` itself represents a leap second in which case the assumption becomes that there is exactly a single leap second ever.

# Example

    use chrono::{Duration, NaiveTime};

    let from_hmsm = NaiveTime::from_hms_milli;

    assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::zero(),                  from_hmsm(3, 5, 7, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(1),              from_hmsm(3, 5, 6, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(60 + 5),         from_hmsm(3, 4, 2, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(2*60*60 + 6*60), from_hmsm(0, 59, 7, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::milliseconds(80),        from_hmsm(3, 5, 6, 920));
    assert_eq!(from_hmsm(3, 5, 7, 950) - Duration::milliseconds(280),     from_hmsm(3, 5, 7, 670));

The subtraction wraps around.

    assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(8*60*60), from_hmsm(19, 5, 7, 0));
    assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::days(800),        from_hmsm(3, 5, 7, 0));

Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.

    let leap = from_hmsm(3, 5, 59, 1_300);
    assert_eq!(leap - Duration::zero(),            from_hmsm(3, 5, 59, 1_300));
    assert_eq!(leap - Duration::milliseconds(200), from_hmsm(3, 5, 59, 1_100));
    assert_eq!(leap - Duration::milliseconds(500), from_hmsm(3, 5, 59, 800));
    assert_eq!(leap - Duration::seconds(60),       from_hmsm(3, 5, 0, 300));
    assert_eq!(leap - Duration::days(1),           from_hmsm(3, 6, 0, 300));

#### `type Output = NaiveTime`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: OldDuration) -> NaiveTime` [src]

Performs the `-` operation. Read more

### `impl<Tz: TimeZone> Sub<Duration> for Date<Tz>` [src]

#### `type Output = Date<Tz>`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: OldDuration) -> Date<Tz>` [src]

Performs the `-` operation. Read more

### `impl<Tz: TimeZone> Sub<Duration> for DateTime<Tz>` [src]

#### `type Output = DateTime<Tz>`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: OldDuration) -> DateTime<Tz>` [src]

Performs the `-` operation. Read more

### `impl SubAssign<Duration> for NaiveDate` [src]

#### `fn sub_assign(&mut self, rhs: OldDuration)` [src]

Performs the `-=` operation. Read more

### `impl SubAssign<Duration> for NaiveDateTime` [src]

#### `fn sub_assign(&mut self, rhs: OldDuration)` [src]

Performs the `-=` operation. Read more

### `impl SubAssign<Duration> for NaiveTime` [src]

#### `fn sub_assign(&mut self, rhs: OldDuration)` [src]

Performs the `-=` operation. Read more

## Auto Trait Implementations

### `impl RefUnwindSafe for Duration`

### `impl Send for Duration`

### `impl Sync for Duration`

### `impl Unpin for Duration`

### `impl UnwindSafe for Duration`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

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

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.