type_eval 0.0.1-alpha

Type level evaluation and proof-carrying
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use core::marker::PhantomData;

use crate::{
    NumExpr,
    _inners::{_BitLit, _BitStrLit, _ExprMode, _Recurse},
};

pub trait NumberVal {}

/// Literal representation of the 0-bit
pub struct _0;
/// Literal representation of the 1-bit
pub struct _1;
/// Literal representation of a bit-string
pub struct B<Bs, B, M: _ExprMode = _Recurse> {
    _bits: PhantomData<Bs>,
    _last_bit: PhantomData<B>,
    _m: PhantomData<M>,
}

/// A [`NumExpr`] can output type-expressed `0`
impl NumberVal for _0 {}
/// A [`NumExpr`] can output type-expressed `1`
impl NumberVal for _1 {}
/// A [`NumExpr`] can output type-expressed `0bxxxx`
impl<Bs, Bt> NumberVal for B<Bs, Bt>
where
    Bs: _BitStrLit,
    Bt: _BitLit,
{
}

/// Trims 0-leading bitstrings semi-automagically
impl<Bt> NumExpr for B<_0, Bt>
where
    Bt: NumberVal,
{
    type Ret = Bt;
}

impl<Bs, Bt> NumExpr for B<Bs, Bt>
where
    Bs: _BitStrLit,
    Bt: _BitLit,
{
    type Ret = Self;
}

impl NumExpr for _0 {
    type Ret = Self;
}
impl NumExpr for _1 {
    type Ret = Self;
}

#[cfg(test)]
#[allow(clippy::used_underscore_items)]
mod test {
    use crate::{
        test_res::*,
        val_types::{B, _0, _1},
    };
    #[test]
    fn eval_trim() {
        const _0_0: () = _b0::<B<_0, _0>>();
        const _0_1: () = _b1::<B<_0, _1>>();
    }
}