Type Definition agnes::label::LVCons

type LVCons<L, V, T> = Cons<Labeled<L, V>, T>;

Label-value cons-list

Trait Implementations

impl<E, L, V, T> Member<E> for LVCons<L, V, T> where
    L: LabelEq<E>,
    T: Member<E>,
    <L as LabelEq<E>>::Eq: BitOr<<T as Member<E>>::IsMember>,
    <<L as LabelEq<E>>::Eq as BitOr<<T as Member<E>>::IsMember>>::Output: Bit, 

type IsMember = Or<<L as LabelEq<E>>::Eq, <T as Member<E>>::IsMember>

True or False.

impl<L, V, T> IsLabelSet for LVCons<L, V, T> where
    T: Member<L>,
    <T as Member<L>>::IsMember: Not,
    <<T as Member<L>>::IsMember as Not>::Output: BitAnd<<T as IsLabelSet>::IsSet>,
    T: IsLabelSet, 

type IsSet = And<<<T as Member<L>>::IsMember as Not>::Output, <T as IsLabelSet>::IsSet>

True or False.

impl<LLabel, LValue, LTail> SetDiff<Nil> for LVCons<LLabel, LValue, LTail>

type Set = LVCons<LLabel, LValue, LTail>

The set of labels that exist in Self and not in RightSet.

impl<LLabel, LValue, LTail, RLabel, RValue, RTail> SetDiff<Cons<Labeled<RLabel, RValue>, RTail>> for LVCons<LLabel, LValue, LTail> where
    Self: SetDiffStep<LVCons<RLabel, RValue, RTail>, LVCons<RLabel, RValue, RTail>>, 

type Set = Self::Set

The set of labels that exist in Self and not in RightSet.

impl<LLabel, LValue, LTail, FullRightSet> SetDiffStep<Nil, FullRightSet> for LVCons<LLabel, LValue, LTail> where
    LTail: SetDiffStep<FullRightSet, FullRightSet>, 

type Set = LVCons<LLabel, LValue, <LTail as SetDiffStep<FullRightSet, FullRightSet>>::Set>

The set of labels that exist in Self and not in RightSet.

impl<LLabel, LValue, LTail, RLabel, RValue, RTail, FullRightSet> SetDiffStep<Cons<Labeled<RLabel, RValue>, RTail>, FullRightSet> for LVCons<LLabel, LValue, LTail> where
    LLabel: LabelEq<RLabel>,
    Self: SetDiffMatch<LVCons<RLabel, RValue, RTail>, FullRightSet, <LLabel as LabelEq<RLabel>>::Eq>, 

type Set = Self::Set

The set of labels that exist in Self and not in RightSet.

impl<LLabel, LValue, LTail, RLabel, RValue, RTail, FullRightSet> SetDiffMatch<Cons<Labeled<RLabel, RValue>, RTail>, FullRightSet, B0> for LVCons<LLabel, LValue, LTail> where
    LVCons<LLabel, LValue, LTail>: SetDiffStep<RTail, FullRightSet>, 

type Set = <LVCons<LLabel, LValue, LTail> as SetDiffStep<RTail, FullRightSet>>::Set

The set of labels that exist in Self and not in RightSet.

impl<LLabel, LValue, LTail, RLabel, RValue, RTail, FullRightSet> SetDiffMatch<Cons<Labeled<RLabel, RValue>, RTail>, FullRightSet, B1> for LVCons<LLabel, LValue, LTail> where
    LTail: SetDiffStep<RTail, FullRightSet>, 

type Set = <LTail as SetDiffStep<RTail, FullRightSet>>::Set

The set of labels that exist in Self and not in RightSet.

impl<TargetL, L, V, T> LookupNatByLabel<TargetL> for LVCons<L, V, T> where
    TargetL: LabelEq<L>,
    LVCons<L, V, T>: LookupNatByLabelMatch<TargetL, <TargetL as LabelEq<L>>::Eq>, 

type Nat = <LVCons<L, V, T> as LookupNatByLabelMatch<TargetL, <TargetL as LabelEq<L>>::Eq>>::Nat

The backing type-level natural number for L.

fn nat(&self) -> usize

A run-time accessor for Nat.

impl<TargetL, L, V, T> LookupNatByLabelMatch<TargetL, B1> for LVCons<L, V, T>

type Nat = UTerm

Backing type-level natural number for TargetL.

impl<TargetL, L, V, T> LookupNatByLabelMatch<TargetL, B0> for LVCons<L, V, T> where
    T: LookupNatByLabel<TargetL>,
    <T as LookupNatByLabel<TargetL>>::Nat: Add<B1>,
    <<T as LookupNatByLabel<TargetL>>::Nat as Add<B1>>::Output: Unsigned, 

type Nat = Add1<<T as LookupNatByLabel<TargetL>>::Nat>

Backing type-level natural number for TargetL.

impl<LabelList, L, V, T> LabelSubset<LabelList> for LVCons<L, V, T> where
    LabelList: Member<L>,
    LVCons<L, V, T>: LabelSubsetPred<LabelList, <LabelList as Member<L>>::IsMember>, 

type Output = <LVCons<L, V, T> as LabelSubsetPred<LabelList, <LabelList as Member<L>>::IsMember>>::Output

Subset of Self that are labeled with labels in LabelList.

impl<L, V, T, TargetL, TargetV, TargetT> Reorder<Cons<Labeled<TargetL, TargetV>, TargetT>> for LVCons<L, V, T> where
    LVCons<L, V, T>: HasLabels<LVCons<TargetL, TargetV, TargetT>>,
    LVCons<TargetL, TargetV, TargetT>: HasLabels<LVCons<L, V, T>>,
    LVCons<TargetL, TargetV, TargetT>: Reordering<Self>, 

type Output = <LVCons<TargetL, TargetV, TargetT> as Reordering<Self>>::Output

The values from Self, re-ordered to match the ordering of TargetOrdering.

fn reorder(self) -> Self::Output

Reorder this cons-list according to the new ordering TargetOrdering.

impl<L, V, T, TargetL, TargetV, TargetT> Reordering<Cons<Labeled<L, V>, T>> for LVCons<TargetL, TargetV, TargetT> where
    LVCons<L, V, T>: TakeElemByLabel<TargetL>,
    <LVCons<L, V, T> as TakeElemByLabel<TargetL>>::Elem: Valued,
    TargetT: Reordering<<LVCons<L, V, T> as TakeElemByLabel<TargetL>>::Rest>, 

type Output = LVCons<TargetL, <<LVCons<L, V, T> as TakeElemByLabel<TargetL>>::Elem as Valued>::Value, <TargetT as Reordering<<LVCons<L, V, T> as TakeElemByLabel<TargetL>>::Rest>>::Output>

The values from Original, re-ordered to match the ordering of Self.

fn reorder(orig: LVCons<L, V, T>) -> Self::Output

Reorder Original according to the ordering of Self.

impl<Label, Value, Tail> AssocLabels for LVCons<Label, Value, Tail> where
    Tail: AssocLabels, 

type Labels = LabelCons<Label, Tail::Labels>

LabelCons-list of labels associated with the Self cons-list.

impl<L, V, T> StrLabels for LVCons<L, V, T> where
    L: LabelName,
    T: StrLabels, 

fn labels<'a>() -> VecDeque<&'a str>

Returns the labels (as strings) for the labels associated with Self.

fn labels_vec<'a>() -> Vec<&'a str>

Returns the labels (as strings) for the labels associated with Self, collected in a Vec struct.

impl<L, V, T> StrTypes for LVCons<L, V, T> where
    L: LabelName,
    T: StrTypes, 

fn str_types<'a>() -> VecDeque<&'a str>

Returns the string descriptions of the types associated with Self.

impl<Label, Value, Tail> AssocFrameLookup for LVCons<Label, Value, Tail> where
    Tail: AssocFrameLookup, 

type Output = LMCons<Label, FrameDetailMarkers<UTerm, Label>, <Tail as AssocFrameLookup>::Output>

The associated FrameLookupCons.

impl<L, V, Tail> NRows for LVCons<L, V, Tail> where
    V: Valued,
    ValueOf<V>: NRows, 

fn nrows(&self) -> usize

Return the number of rows in this data structure.

impl<Label, Value, Tail> SimpleFrameFields for LVCons<Label, Value, Tail> where
    Tail: SimpleFrameFields, 

type Fields = FieldLookupCons<Label, StoreFieldMarkers<Single, LCons<Label, Nil>>, <Tail as SimpleFrameFields>::Fields>

The computed FrameFields FieldLookupCons cons-list.

impl<RFrameIndex, RFrame, RTail, FrameIndexOffset> UpdateFrameIndex<FrameIndexOffset> for LVCons<RFrameIndex, RFrame, RTail> where
    RFrameIndex: Offset<FrameIndexOffset>,
    RTail: UpdateFrameIndex<FrameIndexOffset>, 

type Output = LVCons<<RFrameIndex as Offset<FrameIndexOffset>>::Output, RFrame, <RTail as UpdateFrameIndex<FrameIndexOffset>>::Output>

ViewFrameCons after updating frame index by FrameIndexOffset.

fn update_frame_label(self) -> Self::Output

Update ViewFrameCons with frame index offset.

impl<FrameIndex, Label, Value, Tail> AsFrameLookup<FrameIndex> for LVCons<Label, Value, Tail> where
    Tail: AsFrameLookup<FrameIndex>, 

type Output = LMCons<Label, FrameDetailMarkers<FrameIndex, Label>, <Tail as AsFrameLookup<FrameIndex>>::Output>

The computed FrameLookupCons.

impl<FrameIndex, Frame, Tail> UpdatePermutation for LVCons<FrameIndex, Frame, Tail> where
    Frame: Valued<Value = Frame>,
    ValueOf<Frame>: UpdatePermutation,
    Tail: UpdatePermutation, 

fn update_permutation(self, order: &[usize]) -> Self

Consumes this object returns a new object with a permutation updated according to the provided indices.

impl<LabelList, L, V, T> SubsetClone<LabelList> for LVCons<L, V, T> where
    LabelList: Member<L>,
    Self: SubsetClonePred<LabelList, <LabelList as Member<L>>::IsMember>, 

type Output = <LVCons<L, V, T> as SubsetClonePred<LabelList, <LabelList as Member<L>>::IsMember>>::Output

Output of applying $req_fn to values in this cons-list which match labels in LabelList.

fn subset_clone(&self) -> Self::Output

Apply $req_fn to value in the head of this cons-list if label of head matches labels of LabelList.