Struct agnes::cons::Cons

pub struct Cons<H, T> {
    pub head: H,
    pub tail: T,
}

Buildling block of a heterogeneous type list.

Fields

head: H

Value of this element of the type list.

tail: T

Remaining elements of the type list.

Trait Implementations

impl<NewH, H, T> PushFront<NewH> for Cons<H, T>

type Output = Cons<NewH, Self>

The resulting cons-list type after pushing the specified H element to the front of the existing list.

fn push_front(self, head: NewH) -> Self::Output

Add an element to the front of this heterogeneous list.

impl<U, H, T> PushBack<U> for Cons<H, T> where
    T: PushBack<U>, 

type Output = Cons<H, T::Output>

The resulting cons-list type after pushing the specified H element to the front of the existing list.

fn push_back(self, elem: U) -> Cons<H, T::Output>

Add an element to the end of this heterogeneous list.

impl<List, H, T> Append<List> for Cons<H, T> where
    T: Append<List>, 

type Appended = Cons<H, T::Appended>

The resulting cons-list type after adding the element of the target list to the end of the existing list.

fn append(self, list: List) -> Cons<H, T::Appended>

Add a list to the end of this heterogeneous list.

impl<Head, Tail> Len for Cons<Head, Tail> where
    Tail: Len,
    <Tail as Len>::Len: Add<B1>,
    <<Tail as Len>::Len as Add<B1>>::Output: Unsigned, 

type Len = Add1<<Tail as Len>::Len>

typenum-based list length.

fn is_empty() -> bool

Returns true if length is 0, and false otherwise.

fn len() -> usize

Returns the length of this list.

impl<NeedleLbl, NeedleValue, NeedleTail, Haystack> HasLabels<Cons<Labeled<NeedleLbl, NeedleValue>, NeedleTail>> for Haystack where
    Haystack: Member<NeedleLbl, IsMember = True>,
    Haystack: HasLabels<NeedleTail>, 

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, 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<H, T> LookupElemByNat<UTerm> for Cons<H, T>

type Elem = H

Type of looked-up element.

fn elem(&self) -> &Self::Elem

Look up the element from this cons-list.

impl<H, T> LookupElemByNat<UInt<UTerm, B1>> for Cons<H, T> where
    T: LookupElemByNat<UTerm>, 

type Elem = <T as LookupElemByNat<UTerm>>::Elem

Type of looked-up element.

fn elem(&self) -> &Self::Elem

Look up the element from this cons-list.

impl<H, T, N> LookupElemByNat<UInt<N, B0>> for Cons<H, T> where
    N: Sub<B1>,
    T: LookupElemByNat<UInt<Sub1<N>, B1>>, 

type Elem = <T as LookupElemByNat<UInt<Sub1<N>, B1>>>::Elem

Type of looked-up element.

fn elem(&self) -> &Self::Elem

Look up the element from this cons-list.

impl<H, T, N, B> LookupElemByNat<UInt<UInt<N, B>, B1>> for Cons<H, T> where
    T: LookupElemByNat<UInt<UInt<N, B>, B0>>, 

type Elem = <T as LookupElemByNat<UInt<UInt<N, B>, B0>>>::Elem

Type of looked-up element.

fn elem(&self) -> &Self::Elem

Look up the element from this cons-list.

impl<H, T> TakeElemByNat<UTerm> for Cons<H, T>

type Elem = H

Type of taken element.

type Rest = T

Type of remaining cons-list after element was taken.

fn take_elem(self) -> (H, T)

Take the element from this cons-list.

impl<H, T> TakeElemByNat<UInt<UTerm, B1>> for Cons<H, T> where
    T: TakeElemByNat<UTerm>, 

type Elem = <T as TakeElemByNat<UTerm>>::Elem

Type of taken element.

type Rest = Cons<H, <T as TakeElemByNat<UTerm>>::Rest>

Type of remaining cons-list after element was taken.

fn take_elem(self) -> (Self::Elem, Self::Rest)

Take the element from this cons-list.

impl<H, T, N> TakeElemByNat<UInt<N, B0>> for Cons<H, T> where
    N: Sub<B1>,
    T: TakeElemByNat<UInt<Sub1<N>, B1>>, 

type Elem = <T as TakeElemByNat<UInt<Sub1<N>, B1>>>::Elem

Type of taken element.

type Rest = Cons<H, <T as TakeElemByNat<UInt<Sub1<N>, B1>>>::Rest>

Type of remaining cons-list after element was taken.

fn take_elem(self) -> (Self::Elem, Self::Rest)

Take the element from this cons-list.

impl<H, T, N, B> TakeElemByNat<UInt<UInt<N, B>, B1>> for Cons<H, T> where
    T: TakeElemByNat<UInt<UInt<N, B>, B0>>, 

type Elem = <T as TakeElemByNat<UInt<UInt<N, B>, B0>>>::Elem

Type of taken element.

type Rest = Cons<H, <T as TakeElemByNat<UInt<UInt<N, B>, B0>>>::Rest>

Type of remaining cons-list after element was taken.

fn take_elem(self) -> (Self::Elem, Self::Rest)

Take the element from this cons-list.

impl<LabelList, H, T> LabelSubsetPred<LabelList, B1> for Cons<H, T> where
    T: LabelSubset<LabelList>, 

type Output = Cons<H, <T as LabelSubset<LabelList>>::Output>

Subset of Self that are labeled with labels in LabelList.

impl<LabelList, H, T> LabelSubsetPred<LabelList, B0> for Cons<H, T> where
    T: LabelSubset<LabelList>, 

type Output = <T as LabelSubset<LabelList>>::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, FrameIndex, FrameLabel, Tail, Frames, Store> JoinIntoStore<Cons<Labeled<Label, PhantomData<FrameDetailMarkers<FrameIndex, FrameLabel>>>, Tail>, Store> for Frames where
    Frames: LookupValuedElemByLabel<FrameIndex>,
    FrameByFrameIndexOf<Frames, FrameIndex>: SelectFieldByLabel<FrameLabel>,
    FieldTypeFromFrameDetailsOf<Frames, FrameIndex, FrameLabel>: Debug,
    Store: PushBackClonedFromValueIter<Label, FieldTypeFromFrameDetailsOf<Frames, FrameIndex, FrameLabel>>,
    Frames: JoinIntoStore<Tail, DataStore<<Store as PushBackClonedFromValueIter<Label, FieldTypeFromFrameDetailsOf<Frames, FrameIndex, FrameLabel>>>::OutputFields>>, 

type Output = <Frames as JoinIntoStore<Tail, DataStore<<Store as PushBackClonedFromValueIter<Label, FieldTypeFromFrameDetailsOf<Frames, FrameIndex, FrameLabel>>>::OutputFields>>>::Output

The output type after augmenting Store.

fn join_into_store(
    &self,
    store: Store,
    permutation: &[usize]
) -> Result<Self::Output>

Augments store with data from self (as specified with Labels), using the provided permutation indices.

impl<Label, FrameIndex, FrameLabel, LookupTail, Frames> AssocDataIndexCons<Cons<Labeled<Label, PhantomData<FrameDetailMarkers<FrameIndex, FrameLabel>>>, LookupTail>> for Frames where
    Self: SelectFieldFromLabels<LMCons<Label, FrameDetailMarkers<FrameIndex, FrameLabel>, LookupTail>, Label>,
    Self: AssocDataIndexCons<LookupTail>,
    Self::Output: Typed, 

type Output = DataIndexCons<Label, TypeOf<<Frames as SelectFieldFromLabels<LMCons<Label, FrameDetailMarkers<FrameIndex, FrameLabel>, LookupTail>, Label>>::Output>, <Frames as SelectFieldFromLabels<LMCons<Label, FrameDetailMarkers<FrameIndex, FrameLabel>, LookupTail>, Label>>::Output, <Frames as AssocDataIndexCons<LookupTail>>::Output>

Type of associated data index cons-list.

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

Returns the associated DataIndexCons.

impl<Head, Tail> HashIndex for Cons<Head, Tail> where
    Head: HashIndex,
    Tail: HashIndex, 

fn hash_index<H>(&self, idx: usize, state: &mut H) where
    H: Hasher, 

Compute the hash of the values within this list of data fields with the index idx, updating the hash state.

impl<Head, Tail> PartialEqIndex for Cons<Head, Tail> where
    Head: PartialEqIndex,
    Tail: PartialEqIndex, 

fn eq_index(&self, other: &Self, idx: usize) -> bool

Returns equality of the values within this list of data fields with the index idx.

impl<LabelList, H, T> SubsetClonePred<LabelList, B1> for Cons<H, T> where
    T: SubsetClone<LabelList>,
    H: Clone, 

type Output = Cons<H, <T as SubsetClone<LabelList>>::Output>

Output of applying $req_fn to values in this cons-list if IsMember is True.

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

Apply $req_fn to value in the head of this cons-list if IsMember is True.

impl<LabelList, H, T> SubsetClonePred<LabelList, B0> for Cons<H, T> where
    T: SubsetClone<LabelList>, 

type Output = <T as SubsetClone<LabelList>>::Output

Output of applying $req_fn to values in this cons-list if IsMember is True.

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

Apply $req_fn to value in the head of this cons-list if IsMember is True.

impl<H: Clone, T: Clone> Clone for Cons<H, T>

fn clone(&self) -> Cons<H, T>

Returns a copy of the value.

default fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<H: PartialEq, T: PartialEq> PartialEq<Cons<H, T>> for Cons<H, T>

fn eq(&self, other: &Cons<H, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Cons<H, T>) -> bool

This method tests for !=.

impl<H: Eq, T: Eq> Eq for Cons<H, T>

impl<H: Hash, T: Hash> Hash for Cons<H, T>

fn hash<__HHT: Hasher>(&self, state: &mut __HHT)

Feeds this value into the given [Hasher].

default fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<H: Debug, T: Debug> Debug for Cons<H, T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.