Function malachite_base::tuples::exhaustive::exhaustive_dependent_pairs_stop_after_empty_ys

pub const fn exhaustive_dependent_pairs_stop_after_empty_ys<X: Clone, Y, G: Iterator<Item = usize>, S: ExhaustiveDependentPairsYsGenerator<X, Y, J>, I: Iterator<Item = X>, J: Iterator<Item = Y>>(
    index_generator: G,
    xs: I,
    ys_generator: S
) -> ExhaustiveDependentPairs<X, Y, G, S, I, J> 

Generates pairs $(x, y)$, where the possible values of $y$ depend on the value of $x$. $x$ values with no corresponding $y$ values are treated specially.

See exhaustive_dependent_pairs for context.

If the output iterator encounters an $x$ value whose corresponding ys iterator is empty, the output iterator stops iterating altogether. This prevents the iterator from getting stuck if all ys iterators after a certain point are empty.

Examples

#[macro_use]
extern crate maplit;

use itertools::Itertools;
use malachite_base::num::iterators::ruler_sequence;
use malachite_base::tuples::exhaustive::{
    exhaustive_dependent_pairs_stop_after_empty_ys, ExhaustiveDependentPairsYsGenerator,
};
use std::collections::HashMap;
use std::hash::Hash;
use std::iter::Cloned;
use std::slice::Iter;

#[derive(Clone, Debug)]
struct MultiplesGeneratorHelper {
    u: u64,
    step: u64,
}

impl Iterator for MultiplesGeneratorHelper {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        let next = self.u;
        self.u += self.step;
        Some(next)
    }
}

#[derive(Clone, Debug)]
struct DPGeneratorFromMap<X: Clone + Eq + Hash, Y: 'static + Clone> {
    map: HashMap<X, &'static [Y]>,
}

impl<X: Clone + Eq + Hash, Y: 'static + Clone>
    ExhaustiveDependentPairsYsGenerator<X, Y, Cloned<Iter<'static, Y>>>
    for DPGeneratorFromMap<X, Y>
{
    #[inline]
    fn get_ys(&self, x: &X) -> Cloned<Iter<'static, Y>> {
        self.map[x].iter().cloned()
    }
}

fn main() {
    let xs = [1, 2, 3, 2, 3, 2, 2].iter().cloned();
    let xss = exhaustive_dependent_pairs_stop_after_empty_ys(
        ruler_sequence(),
        xs,
        DPGeneratorFromMap {
            map: hashmap! {
                1 => &[100, 101, 102][..],
                2 => &[][..],
                3 => &[300, 301, 302][..]
            },
        },
    )
    .take(20)
    .collect_vec();
    assert_eq!(xss.as_slice(), &[(1, 100)]);
}