Skip to main content

ForLt

kernel::types

Trait ForLt 

Source 
pub unsafe trait ForLt {
    type Of<'a>: 'a;

    // Provided method
    fn cast_ref<'r, 'short: 'r, 'long: 'short>(
        long: &'r Self::Of<'long>,
    ) -> &'r Self::Of<'short> { ... }
}
Expand description

Representation of types generic over a lifetime.

The type must be covariant over the generic lifetime, i.e. the lifetime parameter can be soundly shortened.

The lifetime involved must be covariant.

§Macro

It is not recommended to implement this trait directly. ForLt! macro is provided to obtain a type that implements this trait.

The full syntax is

ForLt!(for<'a> TypeThatUse<'a>)

which gives a type so that <ForLt!(for<'a> TypeThatUse<'a>) as ForLt>::Of<'b> is TypeThatUse<'b>.

You may also use a short-hand syntax which works similar to lifetime elision. The macro also accepts types that do not involve a lifetime at all.

ForLt!(TypeThatUse<'_>) // Equivalent to `ForLt!(for<'a> TypeThatUse<'a>)`.
ForLt!(&u32) // Equivalent to `ForLt!(for<'a> &'a u32)`.
ForLt!(u32) // Equivalent to `ForLt!(for<'a> u32)`.

The macro will attempt to prove that the type is indeed covariant over the lifetime supplied. When it cannot be syntactically proven, it will emit checks to ask the Rust compiler to prove it.

ⓘ
ForLt!(fn(&u32)) // Contravariant, will fail compilation.

There is a limitation if the type refers to generic parameters; if the macro cannot prove the covariance syntactically, the emitted checks will fail the compilation as it needs to refer to the generic parameter but is in a separate item.

fn expect_lt<F: ForLt>() {}
fn generic_fn<T: 'static>() {
    // Syntactically proven by the macro
    expect_lt::<ForLt!(&T)>();
    // Syntactically proven by the macro
    expect_lt::<ForLt!(&KBox<T>)>();
    // Cannot be syntactically proven, need to check covariance of `KBox`
    // expect_lt::<ForLt!(&KBox<&T>)>();
}

§Safety

Self::Of<'a> must be covariant over the lifetime 'a.

Required Associated Types§

Source

type Of<'a>: 'a

The type parameterized by the lifetime.

Provided Methods§

Source

fn cast_ref<'r, 'short: 'r, 'long: 'short>( long: &'r Self::Of<'long>, ) -> &'r Self::Of<'short>

Cast a reference to a shorter lifetime.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§