Struct Tracked

pub struct Tracked<'a, T, C = <T as Track>::Call>
where
    T: Track + ?Sized,
{ /* private fields */ }

Tracks accesses to a value.

Encapsulates a reference to a value and tracks all accesses to it. The only methods accessible on Tracked<T> are those defined in an implementation block or trait for T annotated with #[track]. For more details, see its documentation.

Variance

Typically you can ignore the defaulted C parameter. However, due to compiler limitations, this type will then be invariant over T. This limits how it can be used. In particular, invariance prevents you from creating a usable chain of tracked types.

struct Chain<'a> {
    outer: Tracked<'a, Self>,
    data: u32, // some data for the chain link
}

However, this is sometimes a useful pattern (for example, it allows you to detect cycles in memoized recursive algorithms). If you want to create a tracked chain or need covariance for another reason, you need to manually specify the call type like so:

struct Chain<'a> {
    outer: Tracked<'a, Self, <Chain<'static> as Track>::Call>,
    data: u32, // some data for the chain link
}

Notice the 'static lifetime: This makes the compiler understand that no strange business that depends on 'a is happening in the associated constraint type. (In fact, all constraints are 'static.)

Trait Implementations

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

where T: Track + ?Sized,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Tracked<'_, T>

where T: Track + ?Sized,

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

Formats the value using the given formatter.

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

where T: Track + ?Sized,

type Target = <T as Surfaces>::Surface<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

where T: Track + ?Sized,