Struct LazyMut

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

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.