Struct UniverseIndex

Source

pub struct UniverseIndex {
    pub(crate) private_use_as_methods_instead: u32,
}

Expand description

“Universes” are used during type- and trait-checking in the presence of for<..> binders to control what sets of names are visible. Universes are arranged into a tree: the root universe contains names that are always visible. Each child then adds a new set of names that are visible, in addition to those of its parent. We say that the child universe “extends” the parent universe with new names.

To make this more concrete, consider this program:

struct Foo { }
fn bar<T>(x: T) {
  let y: for<'a> fn(&'a u8, Foo) = ...;
}

The struct name Foo is in the root universe U0. But the type parameter T, introduced on bar, is in an extended universe U1 – i.e., within bar, we can name both T and Foo, but outside of bar, we cannot name T. Then, within the type of y, the region 'a is in a universe U2 that extends U1, because we can name it inside the fn type but not outside.

Universes are used to do type- and trait-checking around these “forall” binders (also called universal quantification). The idea is that when, in the body of bar, we refer to T as a type, we aren’t referring to any type in particular, but rather a kind of “fresh” type that is distinct from all other types we have actually declared. This is called a placeholder type, and we use universes to talk about this. In other words, a type name in universe 0 always corresponds to some “ground” type that the user declared, but a type name in a non-zero universe is a placeholder type – an idealized representative of “types in general” that we use for checking generic functions.

Fields§

§private_use_as_methods_instead: u32

Struct UniverseIndexCopy item path

Fields§

Implementations§

impl UniverseIndex

pub const MAX_AS_U32: u32 = 4_294_967_040u32

pub const MAX: Self

pub const ZERO: Self

pub const fn from_usize(value: usize) -> Self

§Panics

pub const fn from_u32(value: u32) -> Self

§Panics

pub const fn from_u16(value: u16) -> Self

§Panics

pub const unsafe fn from_u32_unchecked(value: u32) -> Self

§Safety

pub const fn index(self) -> usize

pub const fn as_u32(self) -> u32

pub const fn as_usize(self) -> usize

impl UniverseIndex

pub const ROOT: UniverseIndex = UniverseIndex::ZERO

pub fn next_universe(self) -> UniverseIndex

pub fn can_name(self, other: UniverseIndex) -> bool

pub fn cannot_name(self, other: UniverseIndex) -> bool

pub fn is_root(self) -> bool

Trait Implementations§

impl Add<usize> for UniverseIndex

type Output = UniverseIndex

fn add(self, other: usize) -> Self

impl Clone for UniverseIndex

fn clone(&self) -> UniverseIndex

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

impl Debug for UniverseIndex

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

impl<D: Decoder> Decodable<D> for UniverseIndex

fn decode(d: &mut D) -> Self

impl Default for UniverseIndex

fn default() -> Self

impl<E: Encoder> Encodable<E> for UniverseIndex

fn encode(&self, e: &mut E)

impl From<UniverseIndex> for u32

fn from(v: UniverseIndex) -> u32

impl From<UniverseIndex> for usize

fn from(v: UniverseIndex) -> usize

impl From<u32> for UniverseIndex

fn from(value: u32) -> Self

impl From<usize> for UniverseIndex

fn from(value: usize) -> Self

impl Hash for UniverseIndex

fn hash<__H: Hasher>(&self, state: &mut __H)

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

impl<__CTX> HashStable<__CTX> for UniverseIndex

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl Idx for UniverseIndex

fn new(value: usize) -> Self

fn index(self) -> usize

fn increment_by(&mut self, amount: usize)

fn plus(self, amount: usize) -> Self

impl Ord for UniverseIndex

fn cmp(&self, other: &UniverseIndex) -> Ordering

fn max(self, other: Self) -> Selfwhere Self: Sized,

fn min(self, other: Self) -> Selfwhere Self: Sized,

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized,

impl PartialEq for UniverseIndex

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

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

impl PartialOrd for UniverseIndex

fn partial_cmp(&self, other: &UniverseIndex) -> Option<Ordering>

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

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

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

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

impl Step for UniverseIndex

fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>)

fn forward_checked(start: Self, u: usize) -> Option<Self>

fn backward_checked(start: Self, u: usize) -> Option<Self>

fn forward(start: Self, count: usize) -> Self

unsafe fn forward_unchecked(start: Self, count: usize) -> Self

fn backward(start: Self, count: usize) -> Self

unsafe fn backward_unchecked(start: Self, count: usize) -> Self

impl<I: Interner> TypeFoldable<I> for UniverseIndex

Struct UniverseIndex

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

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

impl<CTX> HashStable<CTX> for UniverseIndex

fn hash_stable(&self, hcx: &mut CTX, __hasher: &mut StableHasher)

fn max(self, other: Self) -> Self
where Self: Sized,

fn min(self, other: Self) -> Self
where Self: Sized,

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

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

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

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

impl<T> CloneToUninit for T
where T: Clone,

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

impl<Q, K> Comparable<K> for Q
where Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

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

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

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

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

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

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