Trait Consumer 

pub trait Consumer<I>:
    WithSetup
    + Send
    + Sized {
    type Folder: Folder<I, Result = Self::Result>;
    type Reducer: Reducer<Self::Result>;
    type Result: Send;

    // Required method
    fn into_folder(self) -> Self::Folder;

    // Provided methods
    fn split(self) -> (Self, Self, Self::Reducer) { ... }
    fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) { ... }
    fn is_full(&self) -> bool { ... }
}

A consumer is effectively a generalized “fold” operation, and in fact each consumer will eventually be converted into a Folder. What makes a consumer special is that, like a Producer, it can be split into multiple consumers using the split_off_left method. When a consumer is split, it produces two consumers, as well as a reducer. The two consumers can be fed items independently, and when they are done the reducer is used to combine their two results into one. See the README for further details.

Required Associated Types

type Folder: Folder<I, Result = Self::Result>

The type of folder that this consumer can be converted into.

type Reducer: Reducer<Self::Result>

The type of reducer that is produced if this consumer is split.

type Result: Send

The type of result that this consumer will ultimately produce.

Required Methods

fn into_folder(self) -> Self::Folder

Convert the consumer into a folder that can consume items sequentially, eventually producing a final result.

Provided Methods

fn split(self) -> (Self, Self, Self::Reducer)

Divide the consumer into two consumers, one processing the left items and one processing the right items from. Also produces a reducer that can be used to reduce the results at the end.

fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer)

Divide the consumer into two consumers, one processing items 0..index and one processing items from index... Also produces a reducer that can be used to reduce the results at the end.

fn is_full(&self) -> bool

Hint whether this Consumer would like to stop processing further items, e.g. if a search has been completed.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors