Node16

tola_caps::trie::node

Struct Node16 

Source 
pub struct Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>(/* private fields */);
Expand description

16-ary internal node - one slot per nibble (0x0..0xF)

Trait Implementations§

Source§

impl<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> Default for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>

Source§

fn default() -> Self

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

impl<QCap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> EvalAt<Has<QCap>, Depth> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where QCap: Capability, Depth: Peano, QCap::Stream: GetTail<Depth>, Self: RouteQuery<QCap, Depth, QCap::At<Depth>>,

Source§

type Out = <Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> as RouteQuery<QCap, Depth, <QCap as Capability>::At<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> InsertAt<Cap, Depth> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, Cap::Stream: GetTail<Depth>, Self: NodeInsert<Cap, Depth, Cap::At<Depth>>,

Source§

type Out = <Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> as NodeInsert<Cap, Depth, <Cap as Capability>::At<Depth>>>::Out

Source§

impl<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> Inspect for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where N0: Inspect + Default, N1: Inspect + Default, N2: Inspect + Default, N3: Inspect + Default, N4: Inspect + Default, N5: Inspect + Default, N6: Inspect + Default, N7: Inspect + Default, N8: Inspect + Default, N9: Inspect + Default, NA: Inspect + Default, NB: Inspect + Default, NC: Inspect + Default, ND: Inspect + Default, NE: Inspect + Default, NF: Inspect + Default,

Inspect impl for Node16 using #[node16(each_slot)]

Source§

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

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

impl<C, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> LeafAndDispatch<C> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>

Source§

type Out = Empty

Source§

impl<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, RA, RB, RC, RD, RE, RF, 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 Node16<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, RA, RB, RC, RD, RE, RF>
where L0: SetAnd<R0>, L1: SetAnd<R1>, L2: SetAnd<R2>, L3: SetAnd<R3>, L4: SetAnd<R4>, L5: SetAnd<R5>, L6: SetAnd<R6>, L7: SetAnd<R7>, L8: SetAnd<R8>, L9: SetAnd<R9>, LA: SetAnd<RA>, LB: SetAnd<RB>, LC: SetAnd<RC>, LD: SetAnd<RD>, LE: SetAnd<RE>, LF: SetAnd<RF>,

Source§

type Out = Node16<<L0 as SetAnd<R0>>::Out, <L1 as SetAnd<R1>>::Out, <L2 as SetAnd<R2>>::Out, <L3 as SetAnd<R3>>::Out, <L4 as SetAnd<R4>>::Out, <L5 as SetAnd<R5>>::Out, <L6 as SetAnd<R6>>::Out, <L7 as SetAnd<R7>>::Out, <L8 as SetAnd<R8>>::Out, <L9 as SetAnd<R9>>::Out, <LA as SetAnd<RA>>::Out, <LB as SetAnd<RB>>::Out, <LC as SetAnd<RC>>::Out, <LD as SetAnd<RD>>::Out, <LE as SetAnd<RE>>::Out, <LF as SetAnd<RF>>::Out>

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X0> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N0: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X1> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N1: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X2> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N2: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X3> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N3: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X4> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N4: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X5> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N5: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X6> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N6: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X7> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N7: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X8> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N8: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, X9> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N9: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, XA> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NA: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, XB> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NB: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, XC> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NC: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, XD> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, ND: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, XE> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NE: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeInsert<Cap, Depth, XF> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NF: InsertAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X0> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N0: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X1> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N1: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X2> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N2: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X3> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N3: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X4> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N4: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X5> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N5: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X6> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N6: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X7> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N7: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X8> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N8: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, X9> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, N9: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, XA> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, NA: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, XB> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, NB: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, XC> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, NC: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, XD> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, ND: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, XE> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, NE: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> NodeRemove<Cap, Depth, XF> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, NF: RemoveAt<Cap, S<Depth>>,

Source§

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

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RemoveAt<Cap, Depth> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, Cap::Stream: GetTail<Depth>, Self: NodeRemove<Cap, Depth, Cap::At<Depth>>,

Source§

type Out = <Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> as NodeRemove<Cap, Depth, <Cap as Capability>::At<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X0> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N0: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N0 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X1> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N1: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N1 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X2> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N2: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N2 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X3> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N3: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N3 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X4> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N4: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N4 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X5> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N5: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N5 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X6> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N6: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N6 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X7> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N7: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N7 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X8> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N8: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N8 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, X9> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, N9: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <N9 as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, XA> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NA: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <NA as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, XB> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NB: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <NB as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, XC> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NC: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <NC as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, XD> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, ND: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <ND as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, XE> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NE: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <NE as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<Cap, Depth, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> RouteQuery<Cap, Depth, XF> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where Cap: Capability, Depth: Peano, NF: EvalAt<Has<Cap>, S<Depth>>,

Source§

type Out = <NF as EvalAt<Has<Cap>, S<Depth>>>::Out

Source§

impl<R, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> SetAnd<R> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where R: NodeAndDispatch<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>,

Source§

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

Source§

impl<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> SetIntersect<Empty> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>

Source§

type Out = Empty

Source§

impl<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> SetUnion<Empty> for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>

Source§

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

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, 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, 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<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> Freeze for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>

§

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

§

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

§

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

§

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

§

impl<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF> UnwindSafe for Node16<N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, NA, NB, NC, ND, NE, NF>
where N0: UnwindSafe, N1: UnwindSafe, N2: UnwindSafe, N3: UnwindSafe, N4: UnwindSafe, N5: UnwindSafe, N6: UnwindSafe, N7: UnwindSafe, N8: UnwindSafe, N9: UnwindSafe, NA: UnwindSafe, NB: UnwindSafe, NC: UnwindSafe, ND: UnwindSafe, NE: UnwindSafe, NF: 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