Struct ImplFolder

pub struct ImplFolder<Output, Item> { /* private fields */ }

The ImplFolder type uses the FolderTrait for the folding function.

• Pros:
  • Slighly more efficient than DynFolder due to monomorphization, which turns .fold calls into direct function calls.
  • Can be used with .collect() if the output type implements Default.
• Cons:
  • Folding function can only use types defined in the user crate, which is a limitation of using traits.
  • Each parameterized ImplFolder, defined by the pair of types, can only have one folding function.

Example:

use autofolder::*;

// Create a type wrapper for usize:
pub struct Usize(usize);

// Create an autofolder that sums `u16` items into an `Usize` output.
let mut sum = ImplFolder::<Usize, u16>::new(Usize(7));

// Implement FolderTrait for the desired ImplFolder type.
autofolder_impl_foldertrait!(|a: Usize, b: u16| {
    Usize(a.0 + b as usize)
});

// We can "fold-in" individual items:
sum.fold(3);

// We can then peek at the running output:
println!("Partial sum is {}", sum.as_ref().0);

// And still keep on folding by processing whole iterators:
sum.extend((1..=5));

// And finally consume the autofolder to get the final output value:
let total = sum.into_inner();
println!("Total sum is {}", total.0);

Implementations

impl<Output, Item> ImplFolder<Output, Item>

pub fn new(initial: Output) -> Self

Creates a new ImplFolder with the provided initial value.

pub fn into_inner(self) -> Output

Deconstruct self and return the inner value.

pub fn fold(&mut self, item: Item)

where Self: FolderTrait<Output, Item>,

Folds an individual value into self.

Trait Implementations

impl<Output, Item> AsRef<Output> for ImplFolder<Output, Item>

fn as_ref(&self) -> &Output

Converts this type into a shared reference of the (usually inferred) input type.

impl<Output: Clone, Item: Clone> Clone for ImplFolder<Output, Item>

fn clone(&self) -> ImplFolder<Output, Item>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Output: Debug, Item: Debug> Debug for ImplFolder<Output, Item>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Output, Item> Default for ImplFolder<Output, Item>

where Output: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Output, Item> Extend<Item> for ImplFolder<Output, Item>

where ImplFolder<Output, Item>: FolderTrait<Output, Item>,

fn extend<It: IntoIterator<Item = Item>>(&mut self, iter: It)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Output, Item> From<Output> for ImplFolder<Output, Item>

fn from(output: Output) -> Self

Converts to this type from the input type.

impl<Output, Item> FromIterator<Item> for ImplFolder<Output, Item>

where Output: Default, ImplFolder<Output, Item>: FolderTrait<Output, Item>,

fn from_iter<It: IntoIterator<Item = Item>>(iter: It) -> Self

Creates a value from an iterator.

impl<Output: Copy, Item: Copy> Copy for ImplFolder<Output, Item>