Leaf

tola_caps::trie::node

Struct Leaf 

Source 
pub struct Leaf<Cap>(/* private fields */);
Expand description

Leaf node containing a single capability

Trait Implementations§

Source§

impl<Cap> Default for Leaf<Cap>

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<Cap, Depth> EvalAt<Has<Cap>, Depth> for &Leaf<Cap>
where Cap: Capability,

Leaf: Exact Identity64 match (higher priority via &) This impl is chosen when QCap == StoredCap (same Identity64 type).

Source§

type Out = Present

Source§

impl<QCap, StoredCap, Depth> EvalAt<Has<QCap>, Depth> for Leaf<StoredCap>
where QCap: Capability, StoredCap: Capability, QCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>,

Source§

type Out = <<QCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out

Source§

impl<NewCap, StoredCap, Depth> InsertAt<NewCap, Depth> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, Depth: Peano, NewCap::Stream: GetTail<Depth>, StoredCap::Stream: GetTail<Depth>, Self: LeafInsert<NewCap, StoredCap, Depth, NewCap::At<Depth>, StoredCap::At<Depth>>,

Source§

type Out = <Leaf<StoredCap> as LeafInsert<NewCap, StoredCap, Depth, <NewCap as Capability>::At<Depth>, <StoredCap as Capability>::At<Depth>>>::Out

Source§

impl<C: Capability> Inspect for Leaf<C>

Source§

fn inspect<F: FnMut(&'static str)>(&self, f: F)

Calls f for each capability in the set with its type name.
Source§

impl<C1, C2> LeafAndDispatch<C1> for Leaf<C2>
where C1: Capability, C2: Capability, C1::Stream: StreamEq<C2::Stream, DefaultMaxDepth>,

Source§

type Out = <<<C1 as Capability>::Stream as StreamEq<<C2 as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Leaf<C1>, Empty>

Source§

impl<Cap, Depth, Nib> LeafCollisionBranch<Cap, Cap, Present, Depth, Nib> for Leaf<Cap>
where Cap: Capability, Nib: Nibble,

Source§

type Out = Leaf<Cap>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X0> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<<<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X1> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X2> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X3> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X4> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X5> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X6> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X7> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X8> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, X9> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, XA> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, XB> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, XC> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, XD> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, XE> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out, Empty>

Source§

impl<NewCap, StoredCap, Depth> LeafCollisionBranch<NewCap, StoredCap, Absent, Depth, XF> for Leaf<StoredCap>
where StoredCap: Capability, NewCap: Capability, Empty: InsertAt<StoredCap, S<Depth>>, <Empty as InsertAt<StoredCap, S<Depth>>>::Out: InsertAt<NewCap, S<Depth>>,

Source§

type Out = Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, <<Empty as InsertAt<StoredCap, S<Depth>>>::Out as InsertAt<NewCap, S<Depth>>>::Out>

Source§

impl<NewCap, StoredCap, Depth, NewNib, StoredNib> LeafInsert<NewCap, StoredCap, Depth, NewNib, StoredNib> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewNib: Nibble + NibbleEq<StoredNib, Out = Absent>, StoredNib: Nibble, EmptyNode16: NodeInsert<StoredCap, Depth, StoredNib>, <EmptyNode16 as NodeInsert<StoredCap, Depth, StoredNib>>::Out: NodeInsert<NewCap, Depth, NewNib>,

Different nibbles: insert both leaves into EmptyNode16 at current depth. Uses NibbleEq<Out = Absent> constraint to ensure NewNib != StoredNib.

Source§

type Out = <<Node16<Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty, Empty> as NodeInsert<StoredCap, Depth, StoredNib>>::Out as NodeInsert<NewCap, Depth, NewNib>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X0, X0> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X0>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X0>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X1, X1> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X1>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X1>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X2, X2> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X2>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X2>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X3, X3> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X3>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X3>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X4, X4> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X4>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X4>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X5, X5> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X5>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X5>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X6, X6> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X6>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X6>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X7, X7> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X7>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X7>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X8, X8> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X8>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X8>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, X9, X9> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, X9>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, X9>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, XA, XA> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, XA>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, XA>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, XB, XB> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, XB>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, XB>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, XC, XC> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, XC>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, XC>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, XD, XD> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, XD>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, XD>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, XE, XE> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, XE>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, XE>>::Out

Source§

impl<NewCap, StoredCap, Depth> LeafInsert<NewCap, StoredCap, Depth, XF, XF> for Leaf<StoredCap>
where NewCap: Capability, StoredCap: Capability, NewCap::Stream: StreamEq<StoredCap::Stream, DefaultMaxDepth>, Self: LeafCollisionBranch<NewCap, StoredCap, <NewCap::Stream as StreamEq<StoredCap::Stream, DefaultMaxDepth>>::Out, Depth, XF>,

Source§

type Out = <Leaf<StoredCap> as LeafCollisionBranch<NewCap, StoredCap, <<NewCap as Capability>::Stream as StreamEq<<StoredCap as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out, Depth, XF>>::Out

Source§

impl<S> LeafRemove<Absent> for Leaf<S>

Source§

type Out = Leaf<S>

Source§

impl<S> LeafRemove<Present> for Leaf<S>

Source§

type Out = Empty

Source§

impl<C, L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, LA, LB, LC, LD, LE, LF> NodeAndDispatch<L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, LA, LB, LC, LD, LE, LF> for Leaf<C>

Source§

type Out = Empty

Source§

impl<StoredCap, QCap, Depth> RemoveAt<QCap, Depth> for Leaf<StoredCap>
where QCap: Capability, StoredCap: Capability, Leaf<StoredCap>: EvalAt<Has<QCap>, Depth> + LeafRemove<<Leaf<StoredCap> as EvalAt<Has<QCap>, Depth>>::Out>,

Source§

type Out = <Leaf<StoredCap> as LeafRemove<<Leaf<StoredCap> as EvalAt<Has<QCap>, Depth>>::Out>>::Out

Source§

impl<C, Other> SetAnd<Other> for Leaf<C>
where Other: LeafAndDispatch<C>,

Source§

type Out = <Other as LeafAndDispatch<C>>::Out

Source§

impl<A> SetIntersect<Empty> for Leaf<A>

Source§

type Out = Empty

Source§

impl<A, B> SetIntersect<Leaf<B>> for Leaf<A>
where A: Capability, B: Capability, A::Stream: StreamEq<B::Stream, DefaultMaxDepth>, <A::Stream as StreamEq<B::Stream, DefaultMaxDepth>>::Out: IntersectLeafHelper<A>,

Source§

type Out = <<<A as Capability>::Stream as StreamEq<<B as Capability>::Stream, S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<S<Z>>>>>>>>>>>>>>>>>>::Out as IntersectLeafHelper<A>>::Out

Source§

impl<A> SetUnion<Empty> for Leaf<A>

Source§

type Out = Leaf<A>

Source§

impl<A, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> SetUnion<Leaf<A>> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where A: Capability, Self: With<A>,

Source§

type Out = <Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> as With<A>>::Out

Source§

impl<A, B> SetUnion<Leaf<B>> for Leaf<A>
where B: Capability, Leaf<A>: With<B>,

Source§

type Out = <Leaf<A> as With<B>>::Out

Source§

impl<A, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> SetUnion<Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>> for Leaf<A>
where A: Capability, Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>: With<A>,

Source§

type Out = <Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> as With<A>>::Out

Source§

impl<A> SupersetOf<Leaf<A>> for Leaf<A>

Source§

impl<A, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> SupersetOf<Leaf<A>> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where A: Capability, Self: Evaluate<Has<A>, Out = Present>,

Auto Trait Implementations§

§

impl<Cap> Freeze for Leaf<Cap>

§

impl<Cap> RefUnwindSafe for Leaf<Cap>
where Cap: RefUnwindSafe,

§

impl<Cap> Send for Leaf<Cap>
where Cap: Send,

§

impl<Cap> Sync for Leaf<Cap>
where Cap: Sync,

§

impl<Cap> Unpin for Leaf<Cap>
where Cap: Unpin,

§

impl<Cap> UnwindSafe for Leaf<Cap>
where Cap: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<Ctx, H, T> Evaluate<All<HCons<H, T>>> for Ctx
where Ctx: Evaluate<H> + Evaluate<All<T>>, <Ctx as Evaluate<H>>::Out: BoolAnd<<Ctx as Evaluate<All<T>>>::Out>,

Source§

type Out = <<Ctx as Evaluate<H>>::Out as BoolAnd<<Ctx as Evaluate<All<T>>>::Out>>::Out

Source§

const RESULT: bool = <Self::Out as Bool>::VALUE

The boolean result of the evaluation as a constant.
Source§

impl<Ctx> Evaluate<All<HNil>> for Ctx

Source§

type Out = Present

Source§

const RESULT: bool = <Self::Out as Bool>::VALUE

The boolean result of the evaluation as a constant.
Source§

impl<Ctx, L, R> Evaluate<And<L, R>> for Ctx
where Ctx: Evaluate<L> + Evaluate<R>, <Ctx as Evaluate<L>>::Out: BoolAnd<<Ctx as Evaluate<R>>::Out>,

Source§

type Out = <<Ctx as Evaluate<L>>::Out as BoolAnd<<Ctx as Evaluate<R>>::Out>>::Out

Source§

const RESULT: bool = <Self::Out as Bool>::VALUE

The boolean result of the evaluation as a constant.
Source§

impl<Ctx, H, T> Evaluate<Any<HCons<H, T>>> for Ctx
where Ctx: Evaluate<H> + Evaluate<Any<T>>, <Ctx as Evaluate<H>>::Out: BoolOr<<Ctx as Evaluate<Any<T>>>::Out>,

Source§

type Out = <<Ctx as Evaluate<H>>::Out as BoolOr<<Ctx as Evaluate<Any<T>>>::Out>>::Out

Source§

const RESULT: bool = <Self::Out as Bool>::VALUE

The boolean result of the evaluation as a constant.
Source§

impl<Ctx> Evaluate<Any<HNil>> for Ctx

Source§

type Out = Absent

Source§

const RESULT: bool = <Self::Out as Bool>::VALUE

The boolean result of the evaluation as a constant.
Source§

impl<Ctx, Cap> Evaluate<Cap> for Ctx
where Cap: Capability, Ctx: EvalAt<Has<Cap>, Z>,

Source§

type Out = <Ctx as EvalAt<Has<Cap>, Z>>::Out

Source§

const RESULT: bool = <Self::Out as Bool>::VALUE

The boolean result of the evaluation as a constant.
Source§

impl<Ctx, L, R> Evaluate<Or<L, R>> for Ctx
where Ctx: Evaluate<L> + Evaluate<R>, <Ctx as Evaluate<L>>::Out: BoolOr<<Ctx as Evaluate<R>>::Out>,

Source§

type Out = <<Ctx as Evaluate<L>>::Out as BoolOr<<Ctx as Evaluate<R>>::Out>>::Out

Source§

const RESULT: bool = <Self::Out as Bool>::VALUE

The boolean result of the evaluation as a constant.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<S, Cap> InsertIf<Cap, false> for S

Source§

type Out = S

Source§

impl<S, Cap> InsertIf<Cap, true> for S
where Cap: Capability, S: InsertAt<Cap, Z>,

Source§

type Out = <S as InsertAt<Cap, Z>>::Out

Source§

impl<S, Cap, B> InsertIfType<Cap, B> for S
where B: Bool, S: InsertAt<Cap, Z>,

Source§

type Out = <B as Bool>::If<<S as InsertAt<Cap, Z>>::Out, S>

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<S, Then, Else> SelectAdd<Then, Else> for S
where S: Evaluate<Marker<Cons<XF, Cons<X9, Cons<XA, Cons<XE, Cons<XE, Cons<X3, Cons<X1, Cons<X9, Cons<XA, Cons<X0, Cons<X0, Cons<X6, Cons<XC, Cons<X9, Cons<XB, ConstStream<X4>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XF, Cons<X9, Cons<XA, Cons<XE, Cons<XE, Cons<X3, Cons<X1, Cons<X9, Cons<XA, Cons<X0, Cons<X0, Cons<X6, Cons<XC, Cons<X9, Cons<XB, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XF, Cons<X9, Cons<XA, Cons<XE, Cons<XE, Cons<X3, Cons<X1, Cons<X9, Cons<XA, Cons<X0, Cons<X0, Cons<X6, Cons<XC, Cons<X9, Cons<XB, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectAddAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<X1, Cons<X6, Cons<XB, Cons<X6, Cons<X5, Cons<X0, Cons<XF, Cons<XA, Cons<X1, Cons<XA, Cons<XD, Cons<X6, Cons<X4, Cons<XA, Cons<X3, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X1, Cons<X6, Cons<XB, Cons<X6, Cons<X5, Cons<X0, Cons<XF, Cons<XA, Cons<X1, Cons<XA, Cons<XD, Cons<X6, Cons<X4, Cons<XA, Cons<X3, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X1, Cons<X6, Cons<XB, Cons<X6, Cons<X5, Cons<X0, Cons<XF, Cons<XA, Cons<X1, Cons<XA, Cons<XD, Cons<X6, Cons<X4, Cons<XA, Cons<X3, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Q1, Q2, Then, Else> SelectAnd<Q1, Q2, Then, Else> for S
where S: SelectCap<And<Q1, Q2>, Then, Else>,

Source§

type Out = <S as SelectCap<And<Q1, Q2>, Then, Else>>::Out

Source§

impl<S, Then, Else> SelectBinary<Then, Else> for S
where S: Evaluate<Marker<Cons<XD, Cons<X6, Cons<XF, Cons<X1, Cons<X3, Cons<X1, Cons<X8, Cons<X8, Cons<X2, Cons<X2, Cons<X0, Cons<XF, Cons<X3, Cons<XD, Cons<X1, ConstStream<XC>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XD, Cons<X6, Cons<XF, Cons<X1, Cons<X3, Cons<X1, Cons<X8, Cons<X8, Cons<X2, Cons<X2, Cons<X0, Cons<XF, Cons<X3, Cons<XD, Cons<X1, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XD, Cons<X6, Cons<XF, Cons<X1, Cons<X3, Cons<X1, Cons<X8, Cons<X8, Cons<X2, Cons<X2, Cons<X0, Cons<XF, Cons<X3, Cons<XD, Cons<X1, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectBitAnd<Then, Else> for S
where S: Evaluate<Marker<Cons<X2, Cons<XB, Cons<XE, Cons<XF, Cons<X9, Cons<XE, Cons<XB, Cons<X7, Cons<X1, Cons<X5, Cons<X8, Cons<X2, Cons<X8, Cons<X7, Cons<X6, ConstStream<X9>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X2, Cons<XB, Cons<XE, Cons<XF, Cons<X9, Cons<XE, Cons<XB, Cons<X7, Cons<X1, Cons<X5, Cons<X8, Cons<X2, Cons<X8, Cons<X7, Cons<X6, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X2, Cons<XB, Cons<XE, Cons<XF, Cons<X9, Cons<XE, Cons<XB, Cons<X7, Cons<X1, Cons<X5, Cons<X8, Cons<X2, Cons<X8, Cons<X7, Cons<X6, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectBitAndAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<X6, Cons<X4, Cons<XD, Cons<X0, Cons<X9, Cons<X4, Cons<XA, Cons<XF, Cons<X2, Cons<XB, Cons<X7, Cons<XD, Cons<X0, Cons<XB, Cons<X8, ConstStream<X0>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X6, Cons<X4, Cons<XD, Cons<X0, Cons<X9, Cons<X4, Cons<XA, Cons<XF, Cons<X2, Cons<XB, Cons<X7, Cons<XD, Cons<X0, Cons<XB, Cons<X8, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X6, Cons<X4, Cons<XD, Cons<X0, Cons<X9, Cons<X4, Cons<XA, Cons<XF, Cons<X2, Cons<XB, Cons<X7, Cons<XD, Cons<X0, Cons<XB, Cons<X8, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectBitOr<Then, Else> for S
where S: Evaluate<Marker<Cons<X2, Cons<XE, Cons<X8, Cons<X7, Cons<XA, Cons<X8, Cons<X2, Cons<XA, Cons<X3, Cons<X4, Cons<X9, Cons<X6, Cons<X7, Cons<XF, Cons<X6, ConstStream<XD>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X2, Cons<XE, Cons<X8, Cons<X7, Cons<XA, Cons<X8, Cons<X2, Cons<XA, Cons<X3, Cons<X4, Cons<X9, Cons<X6, Cons<X7, Cons<XF, Cons<X6, ConstStream<XD>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X2, Cons<XE, Cons<X8, Cons<X7, Cons<XA, Cons<X8, Cons<X2, Cons<XA, Cons<X3, Cons<X4, Cons<X9, Cons<X6, Cons<X7, Cons<XF, Cons<X6, ConstStream<XD>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectBitOrAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<X6, Cons<XE, Cons<X9, Cons<X9, Cons<XE, Cons<XC, Cons<X4, Cons<XE, Cons<X9, Cons<XB, Cons<X8, Cons<X7, Cons<X3, Cons<XB, Cons<X1, ConstStream<X4>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X6, Cons<XE, Cons<X9, Cons<X9, Cons<XE, Cons<XC, Cons<X4, Cons<XE, Cons<X9, Cons<XB, Cons<X8, Cons<X7, Cons<X3, Cons<XB, Cons<X1, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X6, Cons<XE, Cons<X9, Cons<X9, Cons<XE, Cons<XC, Cons<X4, Cons<XE, Cons<X9, Cons<XB, Cons<X8, Cons<X7, Cons<X3, Cons<XB, Cons<X1, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectBitXor<Then, Else> for S
where S: Evaluate<Marker<Cons<XE, Cons<X0, Cons<X6, Cons<X1, Cons<X1, Cons<XF, Cons<XB, Cons<X6, Cons<XE, Cons<XB, Cons<X6, Cons<X4, Cons<XB, Cons<X1, Cons<XA, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XE, Cons<X0, Cons<X6, Cons<X1, Cons<X1, Cons<XF, Cons<XB, Cons<X6, Cons<XE, Cons<XB, Cons<X6, Cons<X4, Cons<XB, Cons<X1, Cons<XA, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XE, Cons<X0, Cons<X6, Cons<X1, Cons<X1, Cons<XF, Cons<XB, Cons<X6, Cons<XE, Cons<XB, Cons<X6, Cons<X4, Cons<XB, Cons<X1, Cons<XA, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectBitXorAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<X6, Cons<XA, Cons<X4, Cons<XB, Cons<X9, Cons<XF, Cons<X9, Cons<XF, Cons<X2, Cons<X1, Cons<XD, Cons<X6, Cons<XD, Cons<XC, Cons<X4, ConstStream<XC>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X6, Cons<XA, Cons<X4, Cons<XB, Cons<X9, Cons<XF, Cons<X9, Cons<XF, Cons<X2, Cons<X1, Cons<XD, Cons<X6, Cons<XD, Cons<XC, Cons<X4, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X6, Cons<XA, Cons<X4, Cons<XB, Cons<X9, Cons<XF, Cons<X9, Cons<XF, Cons<X2, Cons<X1, Cons<XD, Cons<X6, Cons<XD, Cons<XC, Cons<X4, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectBufRead<Then, Else> for S
where S: Evaluate<Marker<Cons<X4, Cons<X0, Cons<X2, Cons<X7, Cons<X2, Cons<XE, Cons<X1, Cons<X6, Cons<X6, Cons<X7, Cons<X1, Cons<X1, Cons<X8, Cons<XB, Cons<X2, ConstStream<XA>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X4, Cons<X0, Cons<X2, Cons<X7, Cons<X2, Cons<XE, Cons<X1, Cons<X6, Cons<X6, Cons<X7, Cons<X1, Cons<X1, Cons<X8, Cons<XB, Cons<X2, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X4, Cons<X0, Cons<X2, Cons<X7, Cons<X2, Cons<XE, Cons<X1, Cons<X6, Cons<X6, Cons<X7, Cons<X1, Cons<X1, Cons<X8, Cons<XB, Cons<X2, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Q, Then, Else> SelectCap<Q, Then, Else> for S
where S: Evaluate<Q>, <S as Evaluate<Q>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Q>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectClone<Then, Else> for S
where S: Evaluate<Marker<Cons<X5, Cons<XE, Cons<X2, Cons<X6, Cons<X5, Cons<X4, Cons<XF, Cons<XB, Cons<X8, Cons<X5, Cons<X8, Cons<X7, Cons<XF, Cons<X4, Cons<X4, ConstStream<X2>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X5, Cons<XE, Cons<X2, Cons<X6, Cons<X5, Cons<X4, Cons<XF, Cons<XB, Cons<X8, Cons<X5, Cons<X8, Cons<X7, Cons<XF, Cons<X4, Cons<X4, ConstStream<X2>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X5, Cons<XE, Cons<X2, Cons<X6, Cons<X5, Cons<X4, Cons<XF, Cons<XB, Cons<X8, Cons<X5, Cons<X8, Cons<X7, Cons<XF, Cons<X4, Cons<X4, ConstStream<X2>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectCopy<Then, Else> for S
where S: Evaluate<Marker<Cons<X3, Cons<X6, Cons<X8, Cons<X7, Cons<X0, Cons<X4, Cons<X9, Cons<XD, Cons<X1, Cons<XA, Cons<XF, Cons<X5, Cons<X6, Cons<X2, Cons<XC, ConstStream<X4>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X3, Cons<X6, Cons<X8, Cons<X7, Cons<X0, Cons<X4, Cons<X9, Cons<XD, Cons<X1, Cons<XA, Cons<XF, Cons<X5, Cons<X6, Cons<X2, Cons<XC, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X3, Cons<X6, Cons<X8, Cons<X7, Cons<X0, Cons<X4, Cons<X9, Cons<XD, Cons<X1, Cons<XA, Cons<XF, Cons<X5, Cons<X6, Cons<X2, Cons<XC, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDebug<Then, Else> for S
where S: Evaluate<Marker<Cons<X9, Cons<X6, Cons<XD, Cons<X2, Cons<XF, Cons<X1, Cons<XD, Cons<XC, Cons<X1, Cons<X8, Cons<X0, Cons<XA, Cons<X4, Cons<X6, Cons<XD, ConstStream<X8>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X9, Cons<X6, Cons<XD, Cons<X2, Cons<XF, Cons<X1, Cons<XD, Cons<XC, Cons<X1, Cons<X8, Cons<X0, Cons<XA, Cons<X4, Cons<X6, Cons<XD, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X9, Cons<X6, Cons<XD, Cons<X2, Cons<XF, Cons<X1, Cons<XD, Cons<XC, Cons<X1, Cons<X8, Cons<X0, Cons<XA, Cons<X4, Cons<X6, Cons<XD, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDefault<Then, Else> for S
where S: Evaluate<Marker<Cons<X1, Cons<X1, Cons<X3, Cons<X2, Cons<X6, Cons<XF, Cons<XD, Cons<X2, Cons<X5, Cons<X9, Cons<X0, Cons<XF, Cons<X4, Cons<XE, Cons<X5, ConstStream<XE>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X1, Cons<X1, Cons<X3, Cons<X2, Cons<X6, Cons<XF, Cons<XD, Cons<X2, Cons<X5, Cons<X9, Cons<X0, Cons<XF, Cons<X4, Cons<XE, Cons<X5, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X1, Cons<X1, Cons<X3, Cons<X2, Cons<X6, Cons<XF, Cons<XD, Cons<X2, Cons<X5, Cons<X9, Cons<X0, Cons<XF, Cons<X4, Cons<XE, Cons<X5, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDeref<Then, Else> for S
where S: Evaluate<Marker<Cons<X2, Cons<X3, Cons<XC, Cons<X0, Cons<X8, Cons<X2, Cons<XD, Cons<XC, Cons<X6, Cons<X8, Cons<X8, Cons<X5, Cons<XF, Cons<X2, Cons<XA, ConstStream<XB>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X2, Cons<X3, Cons<XC, Cons<X0, Cons<X8, Cons<X2, Cons<XD, Cons<XC, Cons<X6, Cons<X8, Cons<X8, Cons<X5, Cons<XF, Cons<X2, Cons<XA, ConstStream<XB>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X2, Cons<X3, Cons<XC, Cons<X0, Cons<X8, Cons<X2, Cons<XD, Cons<XC, Cons<X6, Cons<X8, Cons<X8, Cons<X5, Cons<XF, Cons<X2, Cons<XA, ConstStream<XB>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDerefMut<Then, Else> for S
where S: Evaluate<Marker<Cons<X4, Cons<XE, Cons<XE, Cons<XA, Cons<XC, Cons<XD, Cons<X9, Cons<X8, Cons<X7, Cons<XD, Cons<X8, Cons<X7, Cons<X2, Cons<X9, Cons<XC, ConstStream<X3>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X4, Cons<XE, Cons<XE, Cons<XA, Cons<XC, Cons<XD, Cons<X9, Cons<X8, Cons<X7, Cons<XD, Cons<X8, Cons<X7, Cons<X2, Cons<X9, Cons<XC, ConstStream<X3>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X4, Cons<XE, Cons<XE, Cons<XA, Cons<XC, Cons<XD, Cons<X9, Cons<X8, Cons<X7, Cons<XD, Cons<X8, Cons<X7, Cons<X2, Cons<X9, Cons<XC, ConstStream<X3>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDisplay<Then, Else> for S
where S: Evaluate<Marker<Cons<X1, Cons<X1, Cons<X2, Cons<X5, Cons<XD, Cons<X1, Cons<X5, Cons<X9, Cons<XF, Cons<X7, Cons<XE, Cons<X6, Cons<X4, Cons<XD, Cons<XF, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X1, Cons<X1, Cons<X2, Cons<X5, Cons<XD, Cons<X1, Cons<X5, Cons<X9, Cons<XF, Cons<X7, Cons<XE, Cons<X6, Cons<X4, Cons<XD, Cons<XF, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X1, Cons<X1, Cons<X2, Cons<X5, Cons<XD, Cons<X1, Cons<X5, Cons<X9, Cons<XF, Cons<X7, Cons<XE, Cons<X6, Cons<X4, Cons<XD, Cons<XF, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDiv<Then, Else> for S
where S: Evaluate<Marker<Cons<XE, Cons<X0, Cons<XB, Cons<X1, Cons<X5, Cons<XA, Cons<X1, Cons<X9, Cons<X9, Cons<X2, Cons<X2, Cons<X7, Cons<X6, Cons<X4, Cons<XE, ConstStream<X8>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XE, Cons<X0, Cons<XB, Cons<X1, Cons<X5, Cons<XA, Cons<X1, Cons<X9, Cons<X9, Cons<X2, Cons<X2, Cons<X7, Cons<X6, Cons<X4, Cons<XE, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XE, Cons<X0, Cons<XB, Cons<X1, Cons<X5, Cons<XA, Cons<X1, Cons<X9, Cons<X9, Cons<X2, Cons<X2, Cons<X7, Cons<X6, Cons<X4, Cons<XE, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDivAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<X6, Cons<XC, Cons<XA, Cons<X5, Cons<X6, Cons<X6, Cons<X3, Cons<XC, Cons<XF, Cons<X5, Cons<X9, Cons<X9, Cons<XE, Cons<X6, Cons<X1, ConstStream<X9>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X6, Cons<XC, Cons<XA, Cons<X5, Cons<X6, Cons<X6, Cons<X3, Cons<XC, Cons<XF, Cons<X5, Cons<X9, Cons<X9, Cons<XE, Cons<X6, Cons<X1, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X6, Cons<XC, Cons<XA, Cons<X5, Cons<X6, Cons<X6, Cons<X3, Cons<XC, Cons<XF, Cons<X5, Cons<X9, Cons<X9, Cons<XE, Cons<X6, Cons<X1, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDoubleEndedIterator<Then, Else> for S
where S: Evaluate<Marker<Cons<XE, Cons<X4, Cons<XC, Cons<XD, Cons<X2, Cons<XC, Cons<X1, Cons<XE, Cons<XF, Cons<X5, Cons<X8, Cons<XD, Cons<XC, Cons<X6, Cons<X0, ConstStream<XE>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XE, Cons<X4, Cons<XC, Cons<XD, Cons<X2, Cons<XC, Cons<X1, Cons<XE, Cons<XF, Cons<X5, Cons<X8, Cons<XD, Cons<XC, Cons<X6, Cons<X0, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XE, Cons<X4, Cons<XC, Cons<XD, Cons<X2, Cons<XC, Cons<X1, Cons<XE, Cons<XF, Cons<X5, Cons<X8, Cons<XD, Cons<XC, Cons<X6, Cons<X0, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectDrop<Then, Else> for S
where S: Evaluate<Marker<Cons<X1, Cons<XC, Cons<X3, Cons<X0, Cons<XA, Cons<X8, Cons<X7, Cons<X2, Cons<XD, Cons<XE, Cons<X4, Cons<X5, Cons<XC, Cons<XF, Cons<X8, ConstStream<XC>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X1, Cons<XC, Cons<X3, Cons<X0, Cons<XA, Cons<X8, Cons<X7, Cons<X2, Cons<XD, Cons<XE, Cons<X4, Cons<X5, Cons<XC, Cons<XF, Cons<X8, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X1, Cons<XC, Cons<X3, Cons<X0, Cons<XA, Cons<X8, Cons<X7, Cons<X2, Cons<XD, Cons<XE, Cons<X4, Cons<X5, Cons<XC, Cons<XF, Cons<X8, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectEq<Then, Else> for S
where S: Evaluate<Marker<Cons<X0, Cons<X8, Cons<XF, Cons<XB, Cons<X3, Cons<XB, Cons<X0, Cons<X7, Cons<XB, Cons<X5, Cons<X9, Cons<X6, Cons<X1, Cons<XD, Cons<XA, ConstStream<X3>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X0, Cons<X8, Cons<XF, Cons<XB, Cons<X3, Cons<XB, Cons<X0, Cons<X7, Cons<XB, Cons<X5, Cons<X9, Cons<X6, Cons<X1, Cons<XD, Cons<XA, ConstStream<X3>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X0, Cons<X8, Cons<XF, Cons<XB, Cons<X3, Cons<XB, Cons<X0, Cons<X7, Cons<XB, Cons<X5, Cons<X9, Cons<X6, Cons<X1, Cons<XD, Cons<XA, ConstStream<X3>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectError<Then, Else> for S
where S: Evaluate<Marker<Cons<X5, Cons<XF, Cons<X3, Cons<X4, Cons<X3, Cons<XA, Cons<X4, Cons<X3, Cons<XE, Cons<X7, Cons<XE, Cons<XA, Cons<X9, Cons<XF, Cons<X9, ConstStream<X1>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X5, Cons<XF, Cons<X3, Cons<X4, Cons<X3, Cons<XA, Cons<X4, Cons<X3, Cons<XE, Cons<X7, Cons<XE, Cons<XA, Cons<X9, Cons<XF, Cons<X9, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X5, Cons<XF, Cons<X3, Cons<X4, Cons<X3, Cons<XA, Cons<X4, Cons<X3, Cons<XE, Cons<X7, Cons<XE, Cons<XA, Cons<X9, Cons<XF, Cons<X9, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectExactSizeIterator<Then, Else> for S
where S: Evaluate<Marker<Cons<XA, Cons<XF, Cons<XE, Cons<X4, Cons<X6, Cons<X2, Cons<XA, Cons<X0, Cons<XD, Cons<XA, Cons<XF, Cons<XF, Cons<X1, Cons<XC, Cons<XA, ConstStream<X7>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XA, Cons<XF, Cons<XE, Cons<X4, Cons<X6, Cons<X2, Cons<XA, Cons<X0, Cons<XD, Cons<XA, Cons<XF, Cons<XF, Cons<X1, Cons<XC, Cons<XA, ConstStream<X7>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XA, Cons<XF, Cons<XE, Cons<X4, Cons<X6, Cons<X2, Cons<XA, Cons<X0, Cons<XD, Cons<XA, Cons<XF, Cons<XF, Cons<X1, Cons<XC, Cons<XA, ConstStream<X7>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectFmtWrite<Then, Else> for S
where S: Evaluate<Marker<Cons<X6, Cons<X5, Cons<XA, Cons<X1, Cons<XE, Cons<XD, Cons<XA, Cons<X7, Cons<XC, Cons<XB, Cons<X8, Cons<X8, Cons<XA, Cons<X1, Cons<XE, ConstStream<X7>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X6, Cons<X5, Cons<XA, Cons<X1, Cons<XE, Cons<XD, Cons<XA, Cons<X7, Cons<XC, Cons<XB, Cons<X8, Cons<X8, Cons<XA, Cons<X1, Cons<XE, ConstStream<X7>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X6, Cons<X5, Cons<XA, Cons<X1, Cons<XE, Cons<XD, Cons<XA, Cons<X7, Cons<XC, Cons<XB, Cons<X8, Cons<X8, Cons<XA, Cons<X1, Cons<XE, ConstStream<X7>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectFromStr<Then, Else> for S
where S: Evaluate<Marker<Cons<X7, Cons<X0, Cons<X7, Cons<X5, Cons<X7, Cons<X4, Cons<X2, Cons<XA, Cons<X3, Cons<XA, Cons<X7, Cons<XD, Cons<X0, Cons<X2, Cons<XC, ConstStream<X0>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X7, Cons<X0, Cons<X7, Cons<X5, Cons<X7, Cons<X4, Cons<X2, Cons<XA, Cons<X3, Cons<XA, Cons<X7, Cons<XD, Cons<X0, Cons<X2, Cons<XC, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X7, Cons<X0, Cons<X7, Cons<X5, Cons<X7, Cons<X4, Cons<X2, Cons<XA, Cons<X3, Cons<XA, Cons<X7, Cons<XD, Cons<X0, Cons<X2, Cons<XC, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectFusedIterator<Then, Else> for S
where S: Evaluate<Marker<Cons<XD, Cons<X4, Cons<X0, Cons<X0, Cons<XB, Cons<X1, Cons<X6, Cons<X9, Cons<XE, Cons<XF, Cons<X6, Cons<X9, Cons<XE, Cons<X5, Cons<X5, ConstStream<X6>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XD, Cons<X4, Cons<X0, Cons<X0, Cons<XB, Cons<X1, Cons<X6, Cons<X9, Cons<XE, Cons<XF, Cons<X6, Cons<X9, Cons<XE, Cons<X5, Cons<X5, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XD, Cons<X4, Cons<X0, Cons<X0, Cons<XB, Cons<X1, Cons<X6, Cons<X9, Cons<XE, Cons<XF, Cons<X6, Cons<X9, Cons<XE, Cons<X5, Cons<X5, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectFuture<Then, Else> for S
where S: Evaluate<Marker<Cons<X1, Cons<X4, Cons<X0, Cons<X8, Cons<X3, Cons<X4, Cons<XE, Cons<X3, Cons<XD, Cons<XA, Cons<X0, Cons<XC, Cons<XC, Cons<X2, Cons<X3, ConstStream<X6>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X1, Cons<X4, Cons<X0, Cons<X8, Cons<X3, Cons<X4, Cons<XE, Cons<X3, Cons<XD, Cons<XA, Cons<X0, Cons<XC, Cons<XC, Cons<X2, Cons<X3, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X1, Cons<X4, Cons<X0, Cons<X8, Cons<X3, Cons<X4, Cons<XE, Cons<X3, Cons<XD, Cons<XA, Cons<X0, Cons<XC, Cons<XC, Cons<X2, Cons<X3, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectHash<Then, Else> for S
where S: Evaluate<Marker<Cons<X5, Cons<X8, Cons<XC, Cons<XB, Cons<X9, Cons<XF, Cons<XD, Cons<X8, Cons<X7, Cons<X5, Cons<X8, Cons<XA, Cons<XE, Cons<XB, Cons<XF, ConstStream<X1>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X5, Cons<X8, Cons<XC, Cons<XB, Cons<X9, Cons<XF, Cons<XD, Cons<X8, Cons<X7, Cons<X5, Cons<X8, Cons<XA, Cons<XE, Cons<XB, Cons<XF, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X5, Cons<X8, Cons<XC, Cons<XB, Cons<X9, Cons<XF, Cons<XD, Cons<X8, Cons<X7, Cons<X5, Cons<X8, Cons<XA, Cons<XE, Cons<XB, Cons<XF, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectIntoIterator<Then, Else> for S
where S: Evaluate<Marker<Cons<X3, Cons<XA, Cons<XE, Cons<X1, Cons<XF, Cons<XA, Cons<XB, Cons<XA, Cons<X5, Cons<X9, Cons<XD, Cons<X2, Cons<XD, Cons<X0, Cons<X9, ConstStream<X9>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X3, Cons<XA, Cons<XE, Cons<X1, Cons<XF, Cons<XA, Cons<XB, Cons<XA, Cons<X5, Cons<X9, Cons<XD, Cons<X2, Cons<XD, Cons<X0, Cons<X9, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X3, Cons<XA, Cons<XE, Cons<X1, Cons<XF, Cons<XA, Cons<XB, Cons<XA, Cons<X5, Cons<X9, Cons<XD, Cons<X2, Cons<XD, Cons<X0, Cons<X9, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectIoWrite<Then, Else> for S
where S: Evaluate<Marker<Cons<X3, Cons<X3, Cons<XD, Cons<XC, Cons<XC, Cons<XE, Cons<XF, Cons<X0, Cons<XB, Cons<X4, Cons<XF, Cons<X7, Cons<X6, Cons<X2, Cons<X9, ConstStream<X8>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X3, Cons<X3, Cons<XD, Cons<XC, Cons<XC, Cons<XE, Cons<XF, Cons<X0, Cons<XB, Cons<X4, Cons<XF, Cons<X7, Cons<X6, Cons<X2, Cons<X9, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X3, Cons<X3, Cons<XD, Cons<XC, Cons<XC, Cons<XE, Cons<XF, Cons<X0, Cons<XB, Cons<X4, Cons<XF, Cons<X7, Cons<X6, Cons<X2, Cons<X9, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectIterator<Then, Else> for S
where S: Evaluate<Marker<Cons<XB, Cons<XC, Cons<X8, Cons<XB, Cons<XD, Cons<X1, Cons<XC, Cons<X9, Cons<X2, Cons<XC, Cons<X4, Cons<X2, Cons<X7, Cons<X3, Cons<X0, ConstStream<XF>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XB, Cons<XC, Cons<X8, Cons<XB, Cons<XD, Cons<X1, Cons<XC, Cons<X9, Cons<X2, Cons<XC, Cons<X4, Cons<X2, Cons<X7, Cons<X3, Cons<X0, ConstStream<XF>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XB, Cons<XC, Cons<X8, Cons<XB, Cons<XD, Cons<X1, Cons<XC, Cons<X9, Cons<X2, Cons<XC, Cons<X4, Cons<X2, Cons<X7, Cons<X3, Cons<X0, ConstStream<XF>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectLowerExp<Then, Else> for S
where S: Evaluate<Marker<Cons<XF, Cons<XD, Cons<XB, Cons<XB, Cons<X5, Cons<XF, Cons<X6, Cons<X2, Cons<X4, Cons<XD, Cons<X2, Cons<X4, Cons<XC, Cons<X8, Cons<X4, ConstStream<XD>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XF, Cons<XD, Cons<XB, Cons<XB, Cons<X5, Cons<XF, Cons<X6, Cons<X2, Cons<X4, Cons<XD, Cons<X2, Cons<X4, Cons<XC, Cons<X8, Cons<X4, ConstStream<XD>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XF, Cons<XD, Cons<XB, Cons<XB, Cons<X5, Cons<XF, Cons<X6, Cons<X2, Cons<X4, Cons<XD, Cons<X2, Cons<X4, Cons<XC, Cons<X8, Cons<X4, ConstStream<XD>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectLowerHex<Then, Else> for S
where S: Evaluate<Marker<Cons<X8, Cons<XD, Cons<XD, Cons<X4, Cons<X3, Cons<X6, Cons<X6, Cons<X2, Cons<X0, Cons<XD, Cons<XF, Cons<X5, Cons<XD, Cons<X3, Cons<X8, ConstStream<X3>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X8, Cons<XD, Cons<XD, Cons<X4, Cons<X3, Cons<X6, Cons<X6, Cons<X2, Cons<X0, Cons<XD, Cons<XF, Cons<X5, Cons<XD, Cons<X3, Cons<X8, ConstStream<X3>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X8, Cons<XD, Cons<XD, Cons<X4, Cons<X3, Cons<X6, Cons<X6, Cons<X2, Cons<X0, Cons<XD, Cons<XF, Cons<X5, Cons<XD, Cons<X3, Cons<X8, ConstStream<X3>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectMul<Then, Else> for S
where S: Evaluate<Marker<Cons<X1, Cons<XD, Cons<XE, Cons<XF, Cons<X8, Cons<X5, Cons<X1, Cons<X9, Cons<XB, Cons<X5, Cons<X0, Cons<X3, Cons<X4, Cons<X9, Cons<X4, ConstStream<X1>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X1, Cons<XD, Cons<XE, Cons<XF, Cons<X8, Cons<X5, Cons<X1, Cons<X9, Cons<XB, Cons<X5, Cons<X0, Cons<X3, Cons<X4, Cons<X9, Cons<X4, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X1, Cons<XD, Cons<XE, Cons<XF, Cons<X8, Cons<X5, Cons<X1, Cons<X9, Cons<XB, Cons<X5, Cons<X0, Cons<X3, Cons<X4, Cons<X9, Cons<X4, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectMulAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<X9, Cons<XB, Cons<X5, Cons<XA, Cons<XE, Cons<X1, Cons<XE, Cons<XA, Cons<XB, Cons<XC, Cons<X4, Cons<X4, Cons<XA, Cons<XE, Cons<XD, ConstStream<X8>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X9, Cons<XB, Cons<X5, Cons<XA, Cons<XE, Cons<X1, Cons<XE, Cons<XA, Cons<XB, Cons<XC, Cons<X4, Cons<X4, Cons<XA, Cons<XE, Cons<XD, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X9, Cons<XB, Cons<X5, Cons<XA, Cons<XE, Cons<X1, Cons<XE, Cons<XA, Cons<XB, Cons<XC, Cons<X4, Cons<X4, Cons<XA, Cons<XE, Cons<XD, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectNeg<Then, Else> for S
where S: Evaluate<Marker<Cons<X3, Cons<X7, Cons<X4, Cons<X2, Cons<X0, Cons<X5, Cons<X1, Cons<X9, Cons<XC, Cons<X3, Cons<X2, Cons<XA, Cons<XD, Cons<XE, Cons<XC, ConstStream<X1>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X3, Cons<X7, Cons<X4, Cons<X2, Cons<X0, Cons<X5, Cons<X1, Cons<X9, Cons<XC, Cons<X3, Cons<X2, Cons<XA, Cons<XD, Cons<XE, Cons<XC, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X3, Cons<X7, Cons<X4, Cons<X2, Cons<X0, Cons<X5, Cons<X1, Cons<X9, Cons<XC, Cons<X3, Cons<X2, Cons<XA, Cons<XD, Cons<XE, Cons<XC, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Q, Then, Else> SelectNot<Q, Then, Else> for S
where S: SelectCap<Not<Q>, Then, Else>,

Source§

type Out = <S as SelectCap<Not<Q>, Then, Else>>::Out

Source§

impl<S, Then, Else> SelectNot<Then, Else> for S
where S: Evaluate<Marker<Cons<X3, Cons<X7, Cons<X6, Cons<X3, Cons<XF, Cons<X6, Cons<X1, Cons<X9, Cons<XC, Cons<X3, Cons<X4, Cons<X7, Cons<XA, Cons<XB, Cons<XA, ConstStream<XA>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X3, Cons<X7, Cons<X6, Cons<X3, Cons<XF, Cons<X6, Cons<X1, Cons<X9, Cons<XC, Cons<X3, Cons<X4, Cons<X7, Cons<XA, Cons<XB, Cons<XA, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X3, Cons<X7, Cons<X6, Cons<X3, Cons<XF, Cons<X6, Cons<X1, Cons<X9, Cons<XC, Cons<X3, Cons<X4, Cons<X7, Cons<XA, Cons<XB, Cons<XA, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectOctal<Then, Else> for S
where S: Evaluate<Marker<Cons<XD, Cons<X5, Cons<XD, Cons<X8, Cons<X7, Cons<XB, Cons<X6, Cons<X3, Cons<X4, Cons<XD, Cons<X0, Cons<X5, Cons<X0, Cons<XD, Cons<X7, ConstStream<XC>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XD, Cons<X5, Cons<XD, Cons<X8, Cons<X7, Cons<XB, Cons<X6, Cons<X3, Cons<X4, Cons<XD, Cons<X0, Cons<X5, Cons<X0, Cons<XD, Cons<X7, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XD, Cons<X5, Cons<XD, Cons<X8, Cons<X7, Cons<XB, Cons<X6, Cons<X3, Cons<X4, Cons<XD, Cons<X0, Cons<X5, Cons<X0, Cons<XD, Cons<X7, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Q1, Q2, Then, Else> SelectOr<Q1, Q2, Then, Else> for S
where S: SelectCap<Or<Q1, Q2>, Then, Else>,

Source§

type Out = <S as SelectCap<Or<Q1, Q2>, Then, Else>>::Out

Source§

impl<S, Then, Else> SelectOrd<Then, Else> for S
where S: Evaluate<Marker<Cons<X3, Cons<X0, Cons<X0, Cons<X4, Cons<XA, Cons<X9, Cons<X1, Cons<X9, Cons<XB, Cons<XF, Cons<X7, Cons<X8, Cons<XA, Cons<X6, Cons<XA, ConstStream<X0>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X3, Cons<X0, Cons<X0, Cons<X4, Cons<XA, Cons<X9, Cons<X1, Cons<X9, Cons<XB, Cons<XF, Cons<X7, Cons<X8, Cons<XA, Cons<X6, Cons<XA, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X3, Cons<X0, Cons<X0, Cons<X4, Cons<XA, Cons<X9, Cons<X1, Cons<X9, Cons<XB, Cons<XF, Cons<X7, Cons<X8, Cons<XA, Cons<X6, Cons<XA, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectPartialEq<Then, Else> for S
where S: Evaluate<Marker<Cons<X1, Cons<X9, Cons<XE, Cons<X5, Cons<X6, Cons<XB, Cons<X2, Cons<X2, Cons<X5, Cons<XE, Cons<XA, Cons<X1, Cons<X4, Cons<XA, Cons<X5, ConstStream<X4>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X1, Cons<X9, Cons<XE, Cons<X5, Cons<X6, Cons<XB, Cons<X2, Cons<X2, Cons<X5, Cons<XE, Cons<XA, Cons<X1, Cons<X4, Cons<XA, Cons<X5, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X1, Cons<X9, Cons<XE, Cons<X5, Cons<X6, Cons<XB, Cons<X2, Cons<X2, Cons<X5, Cons<XE, Cons<XA, Cons<X1, Cons<X4, Cons<XA, Cons<X5, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectPartialOrd<Then, Else> for S
where S: Evaluate<Marker<Cons<X4, Cons<XB, Cons<X7, Cons<XD, Cons<X8, Cons<X7, Cons<X6, Cons<X6, Cons<X9, Cons<XA, Cons<XF, Cons<XF, Cons<X1, Cons<X3, Cons<X3, ConstStream<X9>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X4, Cons<XB, Cons<X7, Cons<XD, Cons<X8, Cons<X7, Cons<X6, Cons<X6, Cons<X9, Cons<XA, Cons<XF, Cons<XF, Cons<X1, Cons<X3, Cons<X3, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X4, Cons<XB, Cons<X7, Cons<XD, Cons<X8, Cons<X7, Cons<X6, Cons<X6, Cons<X9, Cons<XA, Cons<XF, Cons<XF, Cons<X1, Cons<X3, Cons<X3, ConstStream<X9>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectPointer<Then, Else> for S
where S: Evaluate<Marker<Cons<XD, Cons<X1, Cons<XF, Cons<X4, Cons<X5, Cons<XB, Cons<X4, Cons<X6, Cons<X3, Cons<X9, Cons<X5, Cons<XD, Cons<X6, Cons<XE, Cons<XE, ConstStream<XA>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XD, Cons<X1, Cons<XF, Cons<X4, Cons<X5, Cons<XB, Cons<X4, Cons<X6, Cons<X3, Cons<X9, Cons<X5, Cons<XD, Cons<X6, Cons<XE, Cons<XE, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XD, Cons<X1, Cons<XF, Cons<X4, Cons<X5, Cons<XB, Cons<X4, Cons<X6, Cons<X3, Cons<X9, Cons<X5, Cons<XD, Cons<X6, Cons<XE, Cons<XE, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectRead<Then, Else> for S
where S: Evaluate<Marker<Cons<X7, Cons<X4, Cons<X0, Cons<XD, Cons<X5, Cons<X4, Cons<X2, Cons<XB, Cons<XB, Cons<XE, Cons<X6, Cons<X9, Cons<X6, Cons<XD, Cons<XE, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X7, Cons<X4, Cons<X0, Cons<XD, Cons<X5, Cons<X4, Cons<X2, Cons<XB, Cons<XB, Cons<XE, Cons<X6, Cons<X9, Cons<X6, Cons<XD, Cons<XE, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X7, Cons<X4, Cons<X0, Cons<XD, Cons<X5, Cons<X4, Cons<X2, Cons<XB, Cons<XB, Cons<XE, Cons<X6, Cons<X9, Cons<X6, Cons<XD, Cons<XE, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectRefUnwindSafe<Then, Else> for S
where S: Evaluate<Marker<Cons<XF, Cons<XE, Cons<XE, Cons<XB, Cons<X2, Cons<XA, Cons<X3, Cons<X8, Cons<X8, Cons<X1, Cons<XC, Cons<X8, Cons<XC, Cons<X1, Cons<XF, ConstStream<X6>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XF, Cons<XE, Cons<XE, Cons<XB, Cons<X2, Cons<XA, Cons<X3, Cons<X8, Cons<X8, Cons<X1, Cons<XC, Cons<X8, Cons<XC, Cons<X1, Cons<XF, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XF, Cons<XE, Cons<XE, Cons<XB, Cons<X2, Cons<XA, Cons<X3, Cons<X8, Cons<X8, Cons<X1, Cons<XC, Cons<X8, Cons<XC, Cons<X1, Cons<XF, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectRem<Then, Else> for S
where S: Evaluate<Marker<Cons<X9, Cons<XF, Cons<XF, Cons<X1, Cons<XE, Cons<X7, Cons<X1, Cons<X9, Cons<XF, Cons<XE, Cons<XA, Cons<XC, Cons<X2, Cons<XA, Cons<XC, ConstStream<X7>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X9, Cons<XF, Cons<XF, Cons<X1, Cons<XE, Cons<X7, Cons<X1, Cons<X9, Cons<XF, Cons<XE, Cons<XA, Cons<XC, Cons<X2, Cons<XA, Cons<XC, ConstStream<X7>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X9, Cons<XF, Cons<XF, Cons<X1, Cons<XE, Cons<X7, Cons<X1, Cons<X9, Cons<XF, Cons<XE, Cons<XA, Cons<XC, Cons<X2, Cons<XA, Cons<XC, ConstStream<X7>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectRemAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<XD, Cons<X3, Cons<X7, Cons<XD, Cons<XA, Cons<X0, Cons<X2, Cons<X1, Cons<X9, Cons<X2, Cons<XF, Cons<X7, Cons<X3, Cons<X1, Cons<X7, ConstStream<XE>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XD, Cons<X3, Cons<X7, Cons<XD, Cons<XA, Cons<X0, Cons<X2, Cons<X1, Cons<X9, Cons<X2, Cons<XF, Cons<X7, Cons<X3, Cons<X1, Cons<X7, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XD, Cons<X3, Cons<X7, Cons<XD, Cons<XA, Cons<X0, Cons<X2, Cons<X1, Cons<X9, Cons<X2, Cons<XF, Cons<X7, Cons<X3, Cons<X1, Cons<X7, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectSeek<Then, Else> for S
where S: Evaluate<Marker<Cons<X5, Cons<X7, Cons<X8, Cons<X8, Cons<XD, Cons<X9, Cons<X2, Cons<X4, Cons<XD, Cons<X5, Cons<X5, Cons<XD, Cons<X3, Cons<XF, Cons<XF, ConstStream<X1>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X5, Cons<X7, Cons<X8, Cons<X8, Cons<XD, Cons<X9, Cons<X2, Cons<X4, Cons<XD, Cons<X5, Cons<X5, Cons<XD, Cons<X3, Cons<XF, Cons<XF, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X5, Cons<X7, Cons<X8, Cons<X8, Cons<XD, Cons<X9, Cons<X2, Cons<X4, Cons<XD, Cons<X5, Cons<X5, Cons<XD, Cons<X3, Cons<XF, Cons<XF, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectSend<Then, Else> for S
where S: Evaluate<Marker<Cons<X5, Cons<X7, Cons<XA, Cons<XD, Cons<XF, Cons<X4, Cons<X2, Cons<X4, Cons<XD, Cons<X5, Cons<X7, Cons<XC, Cons<X8, Cons<XA, Cons<X0, ConstStream<XF>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X5, Cons<X7, Cons<XA, Cons<XD, Cons<XF, Cons<X4, Cons<X2, Cons<X4, Cons<XD, Cons<X5, Cons<X7, Cons<XC, Cons<X8, Cons<XA, Cons<X0, ConstStream<XF>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X5, Cons<X7, Cons<XA, Cons<XD, Cons<XF, Cons<X4, Cons<X2, Cons<X4, Cons<XD, Cons<X5, Cons<X7, Cons<XC, Cons<X8, Cons<XA, Cons<X0, ConstStream<XF>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectShl<Then, Else> for S
where S: Evaluate<Marker<Cons<X9, Cons<X8, Cons<X4, Cons<XE, Cons<XC, Cons<X1, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XA, Cons<X3, Cons<X9, Cons<XB, Cons<X3, ConstStream<X6>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X9, Cons<X8, Cons<X4, Cons<XE, Cons<XC, Cons<X1, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XA, Cons<X3, Cons<X9, Cons<XB, Cons<X3, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X9, Cons<X8, Cons<X4, Cons<XE, Cons<XC, Cons<X1, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XA, Cons<X3, Cons<X9, Cons<XB, Cons<X3, ConstStream<X6>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectShlAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<X6, Cons<XC, Cons<X3, Cons<XB, Cons<XD, Cons<X9, Cons<XF, Cons<X8, Cons<XE, Cons<X1, Cons<X7, Cons<X4, Cons<X6, Cons<X8, Cons<X5, ConstStream<XF>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X6, Cons<XC, Cons<X3, Cons<XB, Cons<XD, Cons<X9, Cons<XF, Cons<X8, Cons<XE, Cons<X1, Cons<X7, Cons<X4, Cons<X6, Cons<X8, Cons<X5, ConstStream<XF>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X6, Cons<XC, Cons<X3, Cons<XB, Cons<XD, Cons<X9, Cons<XF, Cons<X8, Cons<XE, Cons<X1, Cons<X7, Cons<X4, Cons<X6, Cons<X8, Cons<X5, ConstStream<XF>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectShr<Then, Else> for S
where S: Evaluate<Marker<Cons<X9, Cons<X8, Cons<X4, Cons<XE, Cons<XB, Cons<XB, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XA, Cons<X3, Cons<X9, Cons<X1, Cons<X0, ConstStream<X4>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X9, Cons<X8, Cons<X4, Cons<XE, Cons<XB, Cons<XB, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XA, Cons<X3, Cons<X9, Cons<X1, Cons<X0, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X9, Cons<X8, Cons<X4, Cons<XE, Cons<XB, Cons<XB, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XA, Cons<X3, Cons<X9, Cons<X1, Cons<X0, ConstStream<X4>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectShrAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<XE, Cons<XB, Cons<XD, Cons<X6, Cons<X7, Cons<X9, Cons<X6, Cons<X7, Cons<X0, Cons<X1, Cons<XB, Cons<X8, Cons<X8, Cons<X3, Cons<X4, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XE, Cons<XB, Cons<XD, Cons<X6, Cons<X7, Cons<X9, Cons<X6, Cons<X7, Cons<X0, Cons<X1, Cons<XB, Cons<X8, Cons<X8, Cons<X3, Cons<X4, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XE, Cons<XB, Cons<XD, Cons<X6, Cons<X7, Cons<X9, Cons<X6, Cons<X7, Cons<X0, Cons<X1, Cons<XB, Cons<X8, Cons<X8, Cons<X3, Cons<X4, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectSized<Then, Else> for S
where S: Evaluate<Marker<Cons<X3, Cons<XE, Cons<X0, Cons<XB, Cons<X4, Cons<XB, Cons<XB, Cons<X5, Cons<X6, Cons<XE, Cons<X0, Cons<X5, Cons<X9, Cons<X1, Cons<XE, ConstStream<X8>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X3, Cons<XE, Cons<X0, Cons<XB, Cons<X4, Cons<XB, Cons<XB, Cons<X5, Cons<X6, Cons<XE, Cons<X0, Cons<X5, Cons<X9, Cons<X1, Cons<XE, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X3, Cons<XE, Cons<X0, Cons<XB, Cons<X4, Cons<XB, Cons<XB, Cons<X5, Cons<X6, Cons<XE, Cons<X0, Cons<X5, Cons<X9, Cons<X1, Cons<XE, ConstStream<X8>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Q, Then, Else, Output> SelectStaticCall<Q, Then, Else, Output> for S
where S: Evaluate<Q>, <S as Evaluate<Q>>::Out: Bool, Then: StaticMethodImpl<Output>, Else: StaticMethodImpl<Output>,

Source§

fn call() -> Output

Source§

impl<S, Then, Else> SelectSub<Then, Else> for S
where S: Evaluate<Marker<Cons<X9, Cons<X8, Cons<X7, Cons<XA, Cons<XB, Cons<XD, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XC, Cons<X8, Cons<XC, Cons<XF, Cons<X5, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X9, Cons<X8, Cons<X7, Cons<XA, Cons<XB, Cons<XD, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XC, Cons<X8, Cons<XC, Cons<XF, Cons<X5, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X9, Cons<X8, Cons<X7, Cons<XA, Cons<XB, Cons<XD, Cons<X1, Cons<X9, Cons<XF, Cons<XA, Cons<XC, Cons<X8, Cons<XC, Cons<XF, Cons<X5, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectSubAssign<Then, Else> for S
where S: Evaluate<Marker<Cons<XC, Cons<XE, Cons<XD, Cons<XC, Cons<XB, Cons<XD, Cons<XB, Cons<X3, Cons<X2, Cons<X0, Cons<X3, Cons<X7, Cons<X4, Cons<XB, Cons<X7, ConstStream<XC>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XC, Cons<XE, Cons<XD, Cons<XC, Cons<XB, Cons<XD, Cons<XB, Cons<X3, Cons<X2, Cons<X0, Cons<X3, Cons<X7, Cons<X4, Cons<XB, Cons<X7, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XC, Cons<XE, Cons<XD, Cons<XC, Cons<XB, Cons<XD, Cons<XB, Cons<X3, Cons<X2, Cons<X0, Cons<X3, Cons<X7, Cons<X4, Cons<XB, Cons<X7, ConstStream<XC>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectSync<Then, Else> for S
where S: Evaluate<Marker<Cons<X0, Cons<X5, Cons<X0, Cons<X7, Cons<X3, Cons<XD, Cons<X2, Cons<X5, Cons<X3, Cons<X7, Cons<XB, Cons<X4, Cons<X5, Cons<XD, Cons<X1, ConstStream<XA>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X0, Cons<X5, Cons<X0, Cons<X7, Cons<X3, Cons<XD, Cons<X2, Cons<X5, Cons<X3, Cons<X7, Cons<XB, Cons<X4, Cons<X5, Cons<XD, Cons<X1, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X0, Cons<X5, Cons<X0, Cons<X7, Cons<X3, Cons<XD, Cons<X2, Cons<X5, Cons<X3, Cons<X7, Cons<XB, Cons<X4, Cons<X5, Cons<XD, Cons<X1, ConstStream<XA>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectToOwned<Then, Else> for S
where S: Evaluate<Marker<Cons<X9, Cons<X7, Cons<XC, Cons<X9, Cons<X1, Cons<X9, Cons<X5, Cons<X6, Cons<X1, Cons<XF, Cons<XC, Cons<XF, Cons<X8, Cons<XB, Cons<XC, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X9, Cons<X7, Cons<XC, Cons<X9, Cons<X1, Cons<X9, Cons<X5, Cons<X6, Cons<X1, Cons<XF, Cons<XC, Cons<XF, Cons<X8, Cons<XB, Cons<XC, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X9, Cons<X7, Cons<XC, Cons<X9, Cons<X1, Cons<X9, Cons<X5, Cons<X6, Cons<X1, Cons<XF, Cons<XC, Cons<XF, Cons<X8, Cons<XB, Cons<XC, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectToString<Then, Else> for S
where S: Evaluate<Marker<Cons<XA, Cons<X2, Cons<X3, Cons<X6, Cons<X4, Cons<XD, Cons<X0, Cons<X8, Cons<X7, Cons<X2, Cons<XE, Cons<XB, Cons<XF, Cons<XA, Cons<XA, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XA, Cons<X2, Cons<X3, Cons<X6, Cons<X4, Cons<XD, Cons<X0, Cons<X8, Cons<X7, Cons<X2, Cons<XE, Cons<XB, Cons<XF, Cons<XA, Cons<XA, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XA, Cons<X2, Cons<X3, Cons<X6, Cons<X4, Cons<XD, Cons<X0, Cons<X8, Cons<X7, Cons<X2, Cons<XE, Cons<XB, Cons<XF, Cons<XA, Cons<XA, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Q, Then, Else> SelectType<Q, Then, Else> for S
where S: Evaluate<Q>, <S as Evaluate<Q>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Q>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectUnpin<Then, Else> for S
where S: Evaluate<Marker<Cons<XB, Cons<XC, Cons<X0, Cons<XC, Cons<XD, Cons<X0, Cons<XB, Cons<X4, Cons<XD, Cons<XF, Cons<XB, Cons<X7, Cons<XD, Cons<XD, Cons<XE, ConstStream<X1>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XB, Cons<XC, Cons<X0, Cons<XC, Cons<XD, Cons<X0, Cons<XB, Cons<X4, Cons<XD, Cons<XF, Cons<XB, Cons<X7, Cons<XD, Cons<XD, Cons<XE, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XB, Cons<XC, Cons<X0, Cons<XC, Cons<XD, Cons<X0, Cons<XB, Cons<X4, Cons<XD, Cons<XF, Cons<XB, Cons<X7, Cons<XD, Cons<XD, Cons<XE, ConstStream<X1>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectUnwindSafe<Then, Else> for S
where S: Evaluate<Marker<Cons<XF, Cons<XA, Cons<XC, Cons<XD, Cons<XC, Cons<XB, Cons<X3, Cons<X5, Cons<X0, Cons<X4, Cons<X4, Cons<X9, Cons<X7, Cons<XE, Cons<X7, ConstStream<X5>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<XF, Cons<XA, Cons<XC, Cons<XD, Cons<XC, Cons<XB, Cons<X3, Cons<X5, Cons<X0, Cons<X4, Cons<X4, Cons<X9, Cons<X7, Cons<XE, Cons<X7, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<XF, Cons<XA, Cons<XC, Cons<XD, Cons<XC, Cons<XB, Cons<X3, Cons<X5, Cons<X0, Cons<X4, Cons<X4, Cons<X9, Cons<X7, Cons<XE, Cons<X7, ConstStream<X5>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectUpperExp<Then, Else> for S
where S: Evaluate<Marker<Cons<X0, Cons<XE, Cons<X2, Cons<X2, Cons<X4, Cons<X1, Cons<X7, Cons<X5, Cons<XD, Cons<X4, Cons<XD, Cons<XB, Cons<X2, Cons<XA, Cons<X7, ConstStream<XE>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X0, Cons<XE, Cons<X2, Cons<X2, Cons<X4, Cons<X1, Cons<X7, Cons<X5, Cons<XD, Cons<X4, Cons<XD, Cons<XB, Cons<X2, Cons<XA, Cons<X7, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X0, Cons<XE, Cons<X2, Cons<X2, Cons<X4, Cons<X1, Cons<X7, Cons<X5, Cons<XD, Cons<X4, Cons<XD, Cons<XB, Cons<X2, Cons<XA, Cons<X7, ConstStream<XE>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<S, Then, Else> SelectUpperHex<Then, Else> for S
where S: Evaluate<Marker<Cons<X7, Cons<XE, Cons<X5, Cons<XB, Cons<X4, Cons<XA, Cons<X7, Cons<X6, Cons<X1, Cons<X4, Cons<X4, Cons<XF, Cons<XF, Cons<X3, Cons<X1, ConstStream<X0>>>>>>>>>>>>>>>>>>, <S as Evaluate<Marker<Cons<X7, Cons<XE, Cons<X5, Cons<XB, Cons<X4, Cons<XA, Cons<X7, Cons<X6, Cons<X1, Cons<X4, Cons<X4, Cons<XF, Cons<XF, Cons<X3, Cons<X1, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out: Bool,

Source§

type Out = <<S as Evaluate<Marker<Cons<X7, Cons<XE, Cons<X5, Cons<XB, Cons<X4, Cons<XA, Cons<X7, Cons<X6, Cons<X1, Cons<X4, Cons<X4, Cons<XF, Cons<XF, Cons<X3, Cons<X1, ConstStream<X0>>>>>>>>>>>>>>>>>>>::Out as Bool>::If<Then, Else>

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<Ctx, Cap> With<Cap> for Ctx
where Cap: Capability, Ctx: InsertAt<Cap, Z>,

Source§

type Out = <Ctx as InsertAt<Cap, Z>>::Out

Source§

impl<Ctx, Cap> Without<Cap> for Ctx
where Cap: Capability, Ctx: RemoveAt<Cap, Z>,

Source§

type Out = <Ctx as RemoveAt<Cap, Z>>::Out

Source§

impl<T> SupersetOf<Empty> for T