Struct type_traits::Assert2

#[repr(transparent)]
pub struct Assert2<L, R>(_);

Static assertion helper for pair of types

This assertion relies on the fact that generic code is always compiled when generic is actually used, hence on its own every constant within Assert would not produce compile error, even if you refer to concrete instance of Assert In order to perform assertion, you must use associated constant, otherwise generic constant is not evaluated.

Implementations

impl<L, R> Assert2<L, R>

pub const IS_SAME_SIZE: () = _

Asserts both types are of the same size

Usage

use type_traits::Assert2;

fn test<T, O>(input: T, default: O) -> O {
    let _ = Assert2::<T, O>::IS_SAME_SIZE;
    default
}

test(0u8, false);

pub const IS_SAME_ALIGN: () = _

Asserts both types are of the minimum alignment.

Usage

use type_traits::Assert2;

fn test<T, O>(input: T, default: O) -> O {
    let _ = Assert2::<T, O>::IS_SAME_ALIGN;
    default
}

test(0u8, false);

pub const IS_LEFT_SIZE_GREATER_OR_EQUAL: () = _

Asserts that L size is greater or equal to R

Usage

use type_traits::{Type, Assert2};

fn test<T, O>(input: T, default: O) -> O {
    assert!(Type::<T>::size() > Type::<O>::size());
    let _ = Assert2::<T, O>::IS_LEFT_SIZE_GREATER_OR_EQUAL;
    default
}

test(0u32, false);

pub const IS_LEFT_SIZE_LESS: () = _

Asserts that L size is less that of R

Usage

use type_traits::{Type, Assert2};

fn test<T, O>(input: T, default: O) -> O {
    assert!(Type::<T>::size() < Type::<O>::size());
    let _ = Assert2::<T, O>::IS_LEFT_SIZE_LESS;
    default
}

test(false, 0u32);

pub const IS_LEFT_ALIGN_GREATER_OR_EQUAL: () = _

Asserts that L minimum alignment is greater or equal to R

Usage

use type_traits::{Type, Assert2};

fn test<T, O>(input: T, default: O) -> O {
    assert!(Type::<T>::align() > Type::<O>::align());
    let _ = Assert2::<T, O>::IS_LEFT_ALIGN_GREATER_OR_EQUAL;
    default
}

test(0u32, false);

pub const IS_LEFT_ALIGN_LESS: () = _

Asserts that L minimum alignment is less that of R

Usage

use type_traits::{Type, Assert2};

fn test<T, O>(input: T, default: O) -> O {
    assert!(Type::<T>::align() < Type::<O>::align());
    let _ = Assert2::<T, O>::IS_LEFT_ALIGN_LESS;
    default
}

test(0u8, 0u32);