Trait BoolExpr 

pub trait BoolExpr {
    type Ret: BoolVal;
}

An expression returning a prelude::BoolVal

Required Associated Types

type Ret: BoolVal

Implementors

impl BoolExpr for AND<False, False, _Base>

type Ret = False

impl BoolExpr for AND<False, True, _Base>

type Ret = False

impl BoolExpr for AND<True, False, _Base>

type Ret = False

impl BoolExpr for AND<True, True, _Base>

type Ret = True

impl BoolExpr for EQ<_0, _0, _Base>

type Ret = True

impl BoolExpr for EQ<_0, _1, _Base>

type Ret = False

impl BoolExpr for EQ<_1, _0, _Base>

type Ret = False

impl BoolExpr for EQ<_1, _1, _Base>

type Ret = True

impl BoolExpr for False

type Ret = False

impl BoolExpr for GT<_0, _0, _Base>

type Ret = False

impl BoolExpr for GT<_0, _1, _Base>

type Ret = False

impl BoolExpr for GT<_1, _0, _Base>

type Ret = True

impl BoolExpr for GT<_1, _1, _Base>

type Ret = False

impl BoolExpr for NOT<False>

type Ret = True

impl BoolExpr for NOT<True>

type Ret = False

impl BoolExpr for OR<False, False, _Base>

type Ret = False

impl BoolExpr for OR<False, True, _Base>

type Ret = True

impl BoolExpr for OR<True, False, _Base>

type Ret = True

impl BoolExpr for OR<True, True, _Base>

type Ret = True

impl BoolExpr for True

type Ret = True

impl<C, T, F> BoolExpr for IF<C, T, F>

where C: BoolExpr, BoolRet<C>: BoolExpr, IF<C::Ret, T, F, _Base>: BoolExpr,

type Ret = <IF<<C as BoolExpr>::Ret, T, F, _Base> as BoolExpr>::Ret

impl<L, R> BoolExpr for AND<L, R>

where L: BoolExpr, R: BoolExpr, AND<L::Ret, R::Ret, _Base>: BoolExpr,

type Ret = <AND<<L as BoolExpr>::Ret, <R as BoolExpr>::Ret, _Base> as BoolExpr>::Ret

impl<L, R> BoolExpr for EQ<L, R>

where L: NumExpr, R: NumExpr, EQ<L::Ret, R::Ret, _Base>: BoolExpr,

type Ret = <EQ<<L as NumExpr>::Ret, <R as NumExpr>::Ret, _Base> as BoolExpr>::Ret

impl<L, R> BoolExpr for GT<L, R>

where L: NumExpr, R: NumExpr, GT<L::Ret, R::Ret, _Base>: BoolExpr,

type Ret = <GT<<L as NumExpr>::Ret, <R as NumExpr>::Ret, _Base> as BoolExpr>::Ret

impl<L, R> BoolExpr for GTE<L, R>

where AddExp<L, U1>: NumExpr, GT<NumRet<AddExp<L, U1>>, R>: BoolExpr,

type Ret = <GT<<AddExp<L, _1> as NumExpr>::Ret, R> as BoolExpr>::Ret

impl<L, R> BoolExpr for LT<L, R>

where L: NumExpr, R: NumExpr, GT<R::Ret, L::Ret, _Base>: BoolExpr,

type Ret = <GT<<R as NumExpr>::Ret, <L as NumExpr>::Ret, _Base> as BoolExpr>::Ret

impl<L, R> BoolExpr for LTE<L, R>

where AddExp<R, U1>: NumExpr, LT<L, NumRet<AddExp<R, U1>>>: BoolExpr,

type Ret = <LT<L, <AddExp<R, _1> as NumExpr>::Ret> as BoolExpr>::Ret

impl<L, R> BoolExpr for OR<L, R>

where L: BoolExpr, R: BoolExpr, OR<L::Ret, R::Ret, _Base>: BoolExpr,

type Ret = <OR<<L as BoolExpr>::Ret, <R as BoolExpr>::Ret, _Base> as BoolExpr>::Ret

impl<LBs, LB> BoolExpr for GT<B<LBs, LB>, _0, _Base>

type Ret = True

impl<LBs, LB> BoolExpr for GT<B<LBs, LB>, _1, _Base>

type Ret = True

impl<LBs, LB, RBs, RB> BoolExpr for EQ<B<LBs, LB>, B<RBs, RB>, _Base>

where LBs: NumExpr, LB: NumExpr, RBs: _BitStrLit, RB: _BitLit, EQ<LB, RB>: BoolExpr, EQ<LBs, RBs>: BoolExpr, AND<EQ<LBs, RBs>, EQ<LB, RB>>: BoolExpr,

type Ret = <AND<EQ<LBs, RBs>, EQ<LB, RB>> as BoolExpr>::Ret

impl<LBs, LB, RBs, RB> BoolExpr for GT<B<LBs, LB>, B<RBs, RB>, _Base>

where GT<LB, RB, _Base>: BoolExpr, _BitwiseGT<BoolRet<GT<LB, RB, _Base>>, LBs, RBs>: BoolExpr,

type Ret = <_BitwiseGT<<GT<LB, RB, _Base> as BoolExpr>::Ret, LBs, RBs> as BoolExpr>::Ret

impl<RBs, RB> BoolExpr for GT<_0, B<RBs, RB>, _Base>

type Ret = False

impl<RBs, RB> BoolExpr for GT<_1, B<RBs, RB>, _Base>

type Ret = False

impl<T, F> BoolExpr for IF<False, T, F, _Base>

where F: BoolExpr,

type Ret = <F as BoolExpr>::Ret

impl<T, F> BoolExpr for IF<True, T, F, _Base>

where T: BoolExpr,

type Ret = <T as BoolExpr>::Ret