Function constmuck::contiguous::from_u8

pub const fn from_u8<T>(integer: u8, bounds: IsContiguous<T, u8>) -> Option<T>

Converts integer: u8 to T if it’s between the minimum and maximum values for T, otherwise returns None.

Requires that T implements Contiguous<Int = u8>

Examples

NonZeroU8

use constmuck::{IsContiguous, contiguous, infer};

use std::num::NonZeroU8;

const ZERO: Option<NonZeroU8> = contiguous::from_u8(0, infer!());
assert_eq!(ZERO, None);

const ONE: Option<NonZeroU8> = contiguous::from_u8(1, IsContiguous!());
assert_eq!(ONE, NonZeroU8::new(1));

const HUNDRED: Option<NonZeroU8> = contiguous::from_u8(100, IsContiguous!(NonZeroU8));
assert_eq!(HUNDRED, NonZeroU8::new(100));

Custom type

use constmuck::{Contiguous, IsContiguous, contiguous, infer};

#[repr(u8)]
#[derive(Debug, PartialEq, Copy, Clone)]
enum Direction {
    Up = 10,
    Down = 11,
    Left = 12,
    Right = 13,
}

unsafe impl Contiguous for Direction {
   type Int = u8;

   const MIN_VALUE: u8 = 10;
   const MAX_VALUE: u8 = 13;
}


const NONE0: Option<Direction> = contiguous::from_u8(0, infer!());
assert_eq!(NONE0, None);

const NONE9: Option<Direction> = contiguous::from_u8(9, infer!());
assert_eq!(NONE9, None);

const UP: Option<Direction> = contiguous::from_u8(10, infer!());
assert_eq!(UP, Some(Direction::Up));

const DOWN: Option<Direction> = contiguous::from_u8(11, IsContiguous!());
assert_eq!(DOWN, Some(Direction::Down));

// Passing the `Direction` type argument is required,
// since any type can `ìmpl PartialEq<Foo> for Direction`.
let left = contiguous::from_u8(12, IsContiguous!(Direction));
assert_eq!(left, Some(Direction::Left));

let right = contiguous::from_u8(13, IsContiguous!(Direction, u8));
assert_eq!(right, Some(Direction::Right));

const NONE14: Option<Direction> = contiguous::from_u8(14, IsContiguous!());
assert_eq!(NONE14, None);