# Struct chalk_ir::DebruijnIndex

``````pub struct DebruijnIndex {
pub(crate) depth: u32,
}``````
Expand description

References the binder at the given depth. The index is a de Bruijn index, so it counts back through the in-scope binders, with 0 being the innermost binder. This is used in impls and the like. For example, if we had a rule like `for<T> { (T: Clone) :- (T: Copy) }`, then `T` would be represented as a `BoundVar(0)` (as the `for` is the innermost binder).

## Fields§

§`depth: u32`

## Implementations§

Innermost index.

One level higher than the innermost index.

Creates a new de Bruijn index with a given depth.

Depth of the De Bruijn index, counting from 0 starting with the innermost binder.

True if the binder identified by this index is within the binder identified by the index `outer_binder`.

##### Example

Imagine you have the following binders in scope

``forall<a> forall<b> forall<c>``

then the Debruijn index for `c` would be `0`, the index for `b` would be 1, and so on. Now consider the following calls:

• `c.within(a) = true`
• `b.within(a) = true`
• `a.within(a) = false`
• `a.within(c) = false`

Returns the resulting index when this value is moved into through one binder.

Update this index in place by shifting it “in” through `amount` number of binders.

Adds `outer_binder` levels to the `self` index. Intuitively, this shifts the `self` index, which was valid at the outer binder, so that it is valid at the innermost binder.

Example: Assume that the following binders are in scope:

``````for<A> for<B> for<C> for<D>
^ outer binder``````

Assume further that the `outer_binder` argument is 2, which means that it is referring to the `for<B>` binder (since `D` would be the innermost binder).

This means that `self` is relative to the binder `B` – so if `self` is 0 (`INNERMOST`), then it refers to `B`, and if `self` is 1, then it refers to `A`.

We will return as follows:

• `0.shifted_in_from(2) = 2` – i.e., `B`, when shifted in to the binding level `D`, has index 2
• `1.shifted_in_from(2) = 3` – i.e., `A`, when shifted in to the binding level `D`, has index 3
• `2.shifted_in_from(1) = 3` – here, we changed the `outer_binder` to refer to `C`. Therefore `2` (relative to `C`) refers to `A`, so the result is still 3 (since `A`, relative to the innermost binder, has index 3).

Returns the resulting index when this value is moved out from `amount` number of new binders.

Update in place by shifting out from `amount` binders.

Subtracts `outer_binder` levels from the `self` index. Intuitively, this shifts the `self` index, which was valid at the innermost binder, to one that is valid at the binder `outer_binder`.

This will return `None` if the `self` index is internal to the outer binder (i.e., if `self < outer_binder`).

Example: Assume that the following binders are in scope:

``````for<A> for<B> for<C> for<D>
^ outer binder``````

Assume further that the `outer_binder` argument is 2, which means that it is referring to the `for<B>` binder (since `D` would be the innermost binder).

This means that the result is relative to the binder `B` – so if `self` is 0 (`INNERMOST`), then it refers to `B`, and if `self` is 1, then it refers to `A`.

We will return as follows:

• `1.shifted_out_to(2) = None` – i.e., the binder for `C` can’t be named from the binding level `B`
• `3.shifted_out_to(2) = Some(1)` – i.e., `A`, when shifted out to the binding level `B`, has index 1

## Trait Implementations§

Returns a copy of the value. Read more
Performs copy-assignment from `source`. Read more
Formats the value using the given formatter. Read more
Feeds this value into the given `Hasher`. Read more
Feeds a slice of this type into the given `Hasher`. Read more
This method returns an `Ordering` between `self` and `other`. Read more
Compares and returns the maximum of two values. Read more
Compares and returns the minimum of two values. Read more
Restrict a value to a certain interval. Read more
This method tests for `self` and `other` values to be equal, and is used by `==`.
This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
This method returns an ordering between `self` and `other` values if one exists. Read more
This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
Apply the given folder `folder` to `self`; `binders` is the number of binders that are in scope when beginning the folder. Typically `binders` starts as 0, but is adjusted when we encounter `Binders<T>` in the IR or other similar constructs.
A convenient alternative to `try_fold_with` for use with infallible folders. Do not override this method, to ensure coherence with `try_fold_with`.
Apply the given visitor `visitor` to `self`; `binders` is the number of binders that are in scope when beginning the visitor. Typically `binders` starts as 0, but is adjusted when we encounter `Binders<T>` in the IR or other similar constructs.

## Blanket Implementations§

Gets the `TypeId` of `self`. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
Cast a value to type `U` using `CastTo`.

Returns the argument unchanged.

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Shifts this term in one level of binders.
Shifts a term valid at `outer_binder` so that it is valid at the innermost binder. See `DebruijnIndex::shifted_in_from` for a detailed explanation.
Shifts a term valid at the innermost binder so that it is valid at `outer_binder`. See `DebruijnIndex::shifted_out_to` for a detailed explanation.
Shifts this term out one level of binders.
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.
Check whether there are free (non-bound) variables.