Macro const_format::assertc_eq

source · [−]

macro_rules! assertc_eq {
    ($($parameters:tt)*) => { ... };
}

Available on crate feature assertc only.

Expand description

Compile-time equality assertion with formatting.

This macro requires the “assertcp” feature to be exported, because it uses some nightly Rust features.

Comparison Arguments

This macro accepts these types for comparison and debug printing:

Standard library types for which PWrapper wrapping that type has a const_eq method. This includes all integer types, &str, slices/arrays of integers/&str, Options of integers/&str, etc.
non-standard-library types that implement FormatMarker with debug formatting
and have a const fn const_eq(&self, other:&Self) -> bool inherent method,

Syntax

This macro uses the same syntax for the format string and formatting arguments as the formatc macro.

Limitations

This macro has these limitations:

It can only use constants that involve concrete types, so while a Type::<u8>::FOO in an argument would be fine, Type::<T>::FOO would not be (T being a type parameter).
Integer arguments must have a type inferrable from context, as described in the integer arguments section in the root module .

Examples

Passing assertion

#![feature(const_mut_refs)]

use const_format::assertc_eq;

use std::mem::size_of;

assertc_eq!(size_of::<usize>(), size_of::<[usize;1]>());

const TWO: u32 = 2;
assertc_eq!(TWO, TWO, "Oh no {} doesn't equal itself!!", TWO);

Failing assertion

This example demonstrates a failing assertion, and how the compiler error looks like as of 2021-09-18.

#![feature(const_mut_refs)]

use const_format::assertc_eq;

use std::mem::size_of;

assertc_eq!(size_of::<u32>(), size_of::<u8>());

This is the compiler output:

error[E0080]: evaluation of constant value failed
 --> src/macros/assertions.rs:296:13
  |
9 | assertc_eq!(size_of::<u32>(), size_of::<u8>());
  |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at '
assertion failed: `(left == right)`
 left: `4`
right: `1`', src/macros/assertions.rs:9:13

Comparing user-defined types

This example demonstrates how you can assert that two values of a user-defined type are equal.

 #![feature(const_mut_refs)]

 use const_format::{Formatter, PWrapper};
 use const_format::{ConstDebug, assertc_eq, try_};

 const POINT: Point = Point{ x: 5, y: 8, z: 13 };
 const OTHER_POINT: Point = Point{ x: 21, y: 34, z: 55 };

 assertc_eq!(POINT, OTHER_POINT);

 #[derive(ConstDebug)]
 pub struct Point {
     pub x: u32,
     pub y: u32,
     pub z: u32,
 }

 impl Point {
     pub const fn const_eq(&self, other: &Self) -> bool {
         self.x == other.x &&
         self.y == other.y &&
         self.z == other.z
     }
 }

This is the compiler output:

error[E0080]: evaluation of constant value failed
  --> src/macros/assertions.rs:331:14
   |
12 |  assertc_eq!(POINT, OTHER_POINT);
   |              ^^^^^^^^^^^^^^^^^^ the evaluated program panicked at '
assertion failed: `(left == right)`
 left: `Point {
    x: 5,
    y: 8,
    z: 13,
}`
right: `Point {
    x: 21,
    y: 34,
    z: 55,
}`', src/macros/assertions.rs:12:14

error: aborting due to previous error