Struct source::Source

pub struct Source<A: 'static>(_);

Methods

impl<A: 'static> Source<A>

pub fn next(&mut self) -> Option<A>

pub fn has_next(&mut self) -> bool

pub fn new<F: FnMut() -> Option<A> + 'static>(function: F) -> Source<A>

pub fn empty() -> Source<A>

pub fn single(a: A) -> Source<A>

pub fn map<B, F: FnMut(A) -> B + 'static>(self, function: F) -> Source<B>

pub fn filter<F: FnMut(&A) -> bool + 'static>(self, function: F) -> Source<A>

pub fn fold<Accumulator, F: FnMut(Accumulator, A) -> Accumulator>(
    self,
    initial: Accumulator,
    function: F
) -> Accumulator

pub fn flat_map<B, Next: FnMut(A) -> Source<B> + 'static>(
    self,
    next: Next
) -> Source<B>

pub fn concat(self, other: Source<A>) -> Source<A>

pub fn append(self, last: A) -> Source<A>

pub fn prepend(self, head: A) -> Source<A>

pub fn count<F: Fn(A) -> bool>(self, predicate: F) -> i32

impl<A> Source<Source<A>>

pub fn flatten(self) -> Source<A>

impl<A: Clone> Source<A>

pub fn peek(&mut self) -> Option<A>

pub fn replicate(n: u32, element: A) -> Source<A>

impl Source<char>

pub fn read_utf8_file(file: &Path) -> Result<Source<char>, Error>

impl<Snippet: Into<Box<str>>> Source<Snippet>

pub fn join<Separator: Into<Box<str>>>(self, separator: Separator) -> String

impl<A: Debug> Source<A>

pub fn debug(self) -> String

Trait Implementations

impl<A, I: Iterator<Item = A> + 'static> From<I> for Source<A>

fn from(iterator: I) -> Self

Performs the conversion.

impl<A> IntoIterator for Source<A>

type Item = A

The type of the elements being iterated over.

type IntoIter = SourceIterator<A>

Which kind of iterator are we turning this into?

Important traits for SourceIterator<A>

impl<A> Iterator for SourceIterator<A> type Item = A;

fn into_iter(self) -> SourceIterator<A>

Creates an iterator from a value.