Trait symbolic::common::AsSelf[−][src]

pub trait AsSelf<'slf> {
    type Ref: ?Sized;
    fn as_self(&'slf self) -> &'slf Self::Ref;
}
Expand description

Safe downcasting of dependent lifetime bounds on structs.

This trait is similar to AsRef, except that it allows to capture the lifetime of the own instance at the time of the borrow. This allows to force it onto the type’s lifetime bounds. This is particularly useful when the type’s lifetime is somehow tied to it’s own existence, such as in self-referential structs. See SelfCell for an implementation that makes use of this.

Implementation

While this trait may be implemented for any type, it is only useful for types that specify a lifetime bound, such as Cow or ByteView. To implement, define Ref as the type with all dependent lifetimes set to 'slf. Then, simply return self in as_self.

use symbolic_common::AsSelf;

struct Foo<'a>(&'a str);

impl<'slf> AsSelf<'slf> for Foo<'_> {
    type Ref = Foo<'slf>;

    fn as_self(&'slf self) -> &Self::Ref {
        self
    }
}

Interior Mutability

Note that if your type uses interior mutability (essentially any type from std::sync, but specifically everything built on top of UnsafeCell), this implicit coercion will not work. The compiler imposes this limitation by declaring any lifetime on such types as invariant, to avoid interior mutations to write back data with the lowered lifetime.

If you are sure that your type will not borrow and store data of the lower lifetime, then implement the coercion with an unsafe transmute:

use std::cell::UnsafeCell;
use symbolic_common::AsSelf;

struct Foo<'a>(UnsafeCell<&'a str>);

impl<'slf> AsSelf<'slf> for Foo<'_> {
    type Ref = Foo<'slf>;

    fn as_self(&'slf self) -> &Self::Ref {
        unsafe { std::mem::transmute(self) }
    }
}

Associated Types

The Self type with 'slf lifetimes, returned by as_self.

Required methods

Returns a reference to self with downcasted lifetime.

Implementations on Foreign Types

Implementors