Skip to main content

## Interned

# Struct Interned

Source

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

Expand description

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§

Source§

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

Source

#### 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§

Source§

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

Source§

#### fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from `source`. Read more
Source§

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

Source§

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

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

#### type Target = T

The resulting type after dereferencing.
Source§

#### fn deref(&self) -> &T

Dereferences the value.
Source§

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

Source§

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

Source§

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

Source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · Source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

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

### impl<'a, T> PartialEq for Interned<'a, T>

Source§

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

Equality operator `==`. Read more
1.0.0 (const: unstable) · Source§

#### fn ne(&self, other: &Rhs) -> bool

Inequality operator `!=`. Read more
Source§

### impl<T> StableHash for Interned<'_, T>
where T: StableHash,

Source§

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

## Auto Trait Implementations§

§

### impl<'a, T> DynSend for Interned<'a, T>
where T: DynSync,

§

### impl<'a, T> Freeze for Interned<'a, T>

§

### impl<'a, T> RefUnwindSafe for Interned<'a, T>
where T: RefUnwindSafe,

§

### impl<'a, T> Send for Interned<'a, T>
where T: Sync,

§

### impl<'a, T> Sync for Interned<'a, T>
where T: Sync,

§

### impl<'a, T> Unpin for Interned<'a, T>

§

### impl<'a, T> UnsafeUnpin for Interned<'a, T>

§

### impl<'a, T> UnwindSafe for Interned<'a, T>
where T: RefUnwindSafe,

## Blanket Implementations§

Source§

### impl<T> Aligned for T

Source§

#### const ALIGN: Alignment = const ALIGN: Alignment = Alignment::of::<Self>();

Alignment of `Self`.
Source§

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

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
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> CloneToUninit for T
where T: Clone,

Source§

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

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T> Instrument for T

Source§

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

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

#### 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
Source§

### impl<T> Pointable for T

Source§

#### const ALIGN: usize

The alignment of pointer.
Source§

#### type Init = T

The type for initializers.
Source§

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

Initializes a with the given initializer. Read more
Source§

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

Dereferences the given pointer. Read more
Source§

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

Mutably dereferences the given pointer. Read more
Source§

#### unsafe fn drop(ptr: usize)

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

### impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

#### type Target = T

🔬This is a nightly-only experimental API. (`arbitrary_self_types`)
The target type on which the method may be called.
Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

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

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
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.
Source§

### impl<T> WithSubscriber for T

Source§

#### 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
Source§

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

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

## 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