Function traversal::dft_cycles

pub fn dft_cycles<'a, T, F, I>(
    root: &'a T, 
    iter_children: F
) -> DftCycles<'a, T, F, I> where
    T: ?Sized,
    F: FnMut(&'a T) -> I,
    I: Iterator<Item = &'a T>,
    T: Eq + Hash, 

This is a shorthand for DftCycles::new, see DftCycles for more information.

Example

#[derive(PartialEq, Eq, Hash)]
struct Vertex(&'static str, Vec<usize>);

//   A <-+
//  /|\  |
// B | C |
//  \|/  |
//   D >-+
//
// Cycles:
// - A -> B -> D -> A
// - A -> D -> A
// - A -> C -> D -> A
let graph = vec![
    Vertex("A", vec![1, 3, 2]), // 0
    Vertex("B", vec![3]),       // 1
    Vertex("C", vec![3]),       // 2
    Vertex("D", vec![0]),       // 3
];

let start = &graph[0]; // A

// `&tree` represents the root `Vertex`.
// The `FnMut(&Vertex) -> Iterator<Item = &Vertex>` returns
// an `Iterator` to get the connected vertices.
let mut cycles = traversal::dft_cycles(start, |vertex| {
    vertex.1.iter().map(|&i| {
        &graph[i]
    })
});

// Map `Iterator<Item = Vec<&Vertex>>` into `Iterator<Item = Vec<&str>>`
let mut cycles = cycles.map(|path| path.iter().map(|vertex| vertex.0).collect::<Vec<_>>());

assert_eq!(cycles.next(), Some(vec!["A", "B", "D"]));
assert_eq!(cycles.next(), Some(vec!["A", "D"]));
assert_eq!(cycles.next(), Some(vec!["A", "C", "D"]));
assert_eq!(cycles.next(), None);