Struct ValuesIterator

pub struct ValuesIterator<'a, List, A = Nil> { /* private fields */ }

An iterator over a labeled heterogeneous cons-list (LVCons) that only provides access to the contained values (as opposed to the LabeledValue object).

For a version that iterates over a cons-list (Cons) without stripping labeled information, see ConsIterator.

This object is usually created by calling iter_values on a list.

Example

This example demonstrates building and iterating over the values of a labeled heterogeneous cons-list.

use lhlist::Label;

new_label![Label1: Vec<usize>];
new_label![Label2: Vec<&'static str>];
new_label![Label3: Vec<f64>];

let test_list = lhlist![
    Label1 = vec![8usize, 4, 1, 5, 2],
    Label2 = vec!["Hello", "World!"],
    Label3 = vec![0.4f64, -3.5, 3.5, 0.3],
];
let iter = test_list.iter_values();

let (item, iter) = iter.next();
assert_eq!(item, &vec![8usize, 4, 1, 5, 2]);
let (item, iter) = iter.next();
assert_eq!(item, &vec!["Hello", "World!"]);
let (item, _) = iter.next();
assert_eq!(item, &vec![0.4f64, -3.5, 3.5, 0.3]);

Implementations

impl<'a, List> ValuesIterator<'a, List>

pub fn new(list: &'a List) -> Self

Creates a new ValuesIterator over an LVCons-list

impl<'a, List, A> ValuesIterator<'a, List, A>

pub fn with_adapter(list: &'a List, adapter: A) -> Self

Creates a new ValuesIterator over an LVCons-list with a specified adapter (see Adapter).

impl<'a, L, T, A> ValuesIterator<'a, LVCons<L, T>, A>

where L: Label, A: Adapter<&'a L::AssocType>,

pub fn next( self, ) -> (<A as Adapter<&'a L::AssocType>>::Output, ValuesIterator<'a, T, A>)

Returns the next value (if exists) along with a new iterator advanced to the next element of the list.

pub fn map<F>( self, f: F, ) -> ValuesIterator<'a, LVCons<L, T>, Cons<MapAdapter<F>, A>>

where F: MapFunc<<A as Adapter<&'a L::AssocType>>::Output>,

Creates an iterator which call a MapFunc on each element.

See MapAdapter for more information.

pub fn collect_into_labeled_hlist<LabelList>( self, ) -> <Self as CollectIntoLabeledHList<LabelList>>::Output

where Self: CollectIntoLabeledHList<LabelList>,

Collects this iterator into a new labeled heterogeneous list

For an example of usage, see the MapAdapter example.

Trait Implementations

impl<'a, A, L, T> CollectIntoHList for ValuesIterator<'a, LVCons<L, T>, A>

where L: Label, A: Adapter<&'a L::AssocType>, ValuesIterator<'a, T, A>: CollectIntoHList,

type Output = Cons<<A as Adapter<&'a <L as Label>::AssocType>>::Output, <ValuesIterator<'a, T, A> as CollectIntoHList>::Output>

Output type of collected list

fn collect_into_hlist(self) -> Self::Output

Collects the contents of an iterator into a cons-list

impl<'a, A> CollectIntoHList for ValuesIterator<'a, Nil, A>

type Output = Nil

Output type of collected list

fn collect_into_hlist(self) -> Self::Output

Collects the contents of an iterator into a cons-list

impl<'a, TargetL, TargetT, A, L, T> CollectIntoLabeledHList<Cons<PhantomData<TargetL>, TargetT>> for ValuesIterator<'a, LVCons<L, T>, A>

where L: Label, TargetL: Label, A: Adapter<&'a L::AssocType, Output = TargetL::AssocType>, ValuesIterator<'a, T, A>: CollectIntoLabeledHList<TargetT>,

type Output = Cons<LabeledValue<TargetL>, <ValuesIterator<'a, T, A> as CollectIntoLabeledHList<TargetT>>::Output>

Output type of collected list

fn collect_into_labeled_hlist(self) -> Self::Output

Collects the contents of an iterator into a labeled cons-list

impl<'a, A> CollectIntoLabeledHList<Nil> for ValuesIterator<'a, Nil, A>

type Output = Nil

Output type of collected list

fn collect_into_labeled_hlist(self) -> Self::Output

Collects the contents of an iterator into a labeled cons-list

impl<'a, List: Debug, A: Debug> Debug for ValuesIterator<'a, List, A>

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

Formats the value using the given formatter.