Struct iterpipes::LazyMut

pub struct LazyMut<I, O, F> where
    F: FnMut(I) -> O,  { /* fields omitted */ }

A "lazily" create pipe with a mutable state.

This pipe's behavior is defined by a callable object, for example a lambda expression, and can therefore be "lazily" created inline.

Since callable objects with mutable state can not be reseted, reset will panic if it's called.

Example

use iterpipes::*;

let mut counter: u8 = 0;
let mut pipe = LazyMut::new(|i: u8| {
    counter += 1;
    i*counter
});

assert_eq!(1, pipe.next(1));
assert_eq!(4, pipe.next(2));

Implementations

impl<I, O, F> LazyMut<I, O, F> where
    F: FnMut(I) -> O, 

pub fn new(function: F) -> Self

Create a new lazy pipe.

Trait Implementations

impl<I, O, F> Pipe for LazyMut<I, O, F> where
    F: FnMut(I) -> O, 

type InputItem = I

The type of input this pipe accepts.

type OutputItem = O

The type of output this pipe produces.

fn next(&mut self, input: I) -> O

Calculate the next output item, based on an input item.

fn bypass(self) -> Bypass<Self> where
    Self: Sized,
    Self::InputItem: Clone, 

Create a bypassed version of the pipe.

fn compose(self) -> Composed<Self> where
    Self: Sized, 

Create a composable pipe.

fn connect<O: Pipe<InputItem = Self::OutputItem>>(
    self,
    other: O
) -> Connector<Self, O> where
    Self: Sized, 

Connect two pipes.

fn into_iter(self) -> IterPipe<Self> where
    Self::InputItem: Default,
    Self: Sized + Pipe<InputItem = ()>, 

Wrap the pipe into an iterator.

fn optional(self) -> Optional<Self> where
    Self: Sized, 

Optionalize the pipe.

fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 

Enumerate the output items of a pipe.

fn boxed(
    self
) -> Box<dyn Pipe<InputItem = Self::InputItem, OutputItem = Self::OutputItem>> where
    Self: Sized + 'static, 

Create a boxed trait object of the pipe.