collections​::slice

Modules

bytesraw

Structs

ChunksElementSwapsItemsMutChunksMutItemsMutSplitsPermutationsSplitsWindows

Traits

CloneableVectorImmutableCloneableVectorImmutableEqVectorImmutableOrdVectorImmutableVectorMutableCloneableVectorMutableOrdVectorMutableVectorMutableVectorAllocatingVectorVectorVector

Functions

mut_ref_sliceref_slice

Struct collections::slice::ElementSwaps[src]

pub struct ElementSwaps {
    // some fields omitted
}

An Iterator that yields the element swaps needed to produce a sequence of all possible permutations for an indexed sequence of elements. Each permutation is only a single swap apart.

The Steinhaus–Johnson–Trotter algorithm is used.

Generates even and odd permutations alternately.

The last generated swap is always (0, 1), and it returns the sequence to its initial order.

Methods

impl ElementSwaps

fn new(length: uint) -> ElementSwaps

Create an ElementSwaps iterator for a sequence of length elements

Trait Implementations

impl Iterator<(uint, uint)> for ElementSwaps

fn next(&mut self) -> Option<(uint, uint)>

fn size_hint(&self) -> (uint, Option<uint>)

fn chain<U: Iterator<A>>(self, other: U) -> Chain<Self, U>

fn zip<B, U: Iterator<B>>(self, other: U) -> Zip<Self, U>

fn map<B>(self, f: |A|: 'r -> B) -> Map<'r, A, B, Self>

fn filter<A>(self, predicate: |&A|: 'r -> bool) -> Filter<'r, A, Self>

fn filter_map<B>(self, f: |A|: 'r -> Option<B>) -> FilterMap<'r, A, B, Self>

fn enumerate<A>(self) -> Enumerate<Self>

fn peekable<A>(self) -> Peekable<A, Self>

fn skip_while<A>(self, predicate: |&A|: 'r -> bool) -> SkipWhile<'r, A, Self>

fn take_while<A>(self, predicate: |&A|: 'r -> bool) -> TakeWhile<'r, A, Self>

fn skip<A>(self, n: uint) -> Skip<Self>

fn take<A>(self, n: uint) -> Take<Self>

fn scan<St, B>(self, initial_state: St, f: |&mut St, A|: 'r -> Option<B>) -> Scan<'r, A, B, Self, St>

fn flat_map<B, U: Iterator<B>>(self, f: |A|: 'r -> U) -> FlatMap<'r, A, Self, U>

fn fuse<A>(self) -> Fuse<Self>

fn inspect<A>(self, f: |&A|: 'r) -> Inspect<'r, A, Self>

fn by_ref<A>(&'r mut self) -> ByRef<'r, Self>

fn advance<A>(&mut self, f: |A| -> bool) -> bool

fn collect<B: FromIterator<A>>(&mut self) -> B

fn nth<A>(&mut self, n: uint) -> Option<A>

fn last<A>(&mut self) -> Option<A>

fn fold<B>(&mut self, init: B, f: |B, A| -> B) -> B

fn count<A>(&mut self) -> uint

fn all<A>(&mut self, f: |A| -> bool) -> bool

fn any<A>(&mut self, f: |A| -> bool) -> bool

fn find<A>(&mut self, predicate: |&A| -> bool) -> Option<A>

fn position<A>(&mut self, predicate: |A| -> bool) -> Option<uint>

fn max_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A>

fn min_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A>