Struct Interned 

pub struct Interned<'a, T>(pub &'a T, pub PrivateZst);

This type is a reference with one special behaviour: the reference pointer (i.e. the address of the value referred to) is used for equality and hashing, rather than the value’s contents, as would occur with a vanilla reference. There are two cases when this is useful.

• Types where uniqueness is guaranteed. This is most commonly achieved via interning – hence the name Interned – though it may also be possible via other means. In this case, the use of Interned is primarily a performance optimization, because pointer equality/hashing gives the same results as value equality/hashing, but is faster. (The use of the Interned type also provides documentation about the interned-ness.)

  Note that in this case it is possible to have a T and a Interned<T> that are (or refer to) equal but different values. But if you have two different Interned<T>s, they both refer to the same value, at a single location in memory.

• Types with identity, where distinct values should always be considered unequal, even if they have equal values. These are rare in Rust, but do occur sometimes. In this case, the use of Interned gives different behaviour, because pointer equality/hashing gives different result to value equality/hashing, and is also faster.

The PrivateZst field means you can pattern match with Interned(v, _) but you can only construct a Interned with new_unchecked, and not directly. This means that all creation points can be audited easily.

Tuple Fields

0: &'a T

1: PrivateZst

Implementations

impl<'a, T> Interned<'a, T>

pub const fn new_unchecked(t: &'a T) -> Self

Create a new Interned value. The value referred to must satisfy one of the following two conditions.

• It must be unique and it must remain unique in the future.
• It must be of a type with “identity” such that distinct values should always be considered unequal.

This function has _unchecked in the name but is not unsafe, because if neither of these conditions is met it will cause incorrect behaviour but will not affect memory safety.

Trait Implementations

impl<'a, T> Clone for Interned<'a, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T> Copy for Interned<'a, T>

impl<T: Debug> Debug for Interned<'_, T>

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

Formats the value using the given formatter.

impl<'a, T> Deref for Interned<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'a, T: DynSync> DynSync for Interned<'a, T>

impl<'a, T> Eq for Interned<'a, T>

impl<'a, T> Hash for Interned<'a, T>

fn hash<H: Hasher>(&self, s: &mut H)

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<'a, T> PartialEq for Interned<'a, T>

fn eq(&self, other: &Self) -> 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<T> StableHash for Interned<'_, T>

where T: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes