Struct Last 

pub struct Last<T> { /* private fields */ }

A Collector that stores the last item it collects.

If no items have been collected, its Output is None; otherwise, it is Some containing the most recently collected item.

This collector corresponds to Iterator::last().

Examples

use better_collect::{prelude::*, Last};

let mut collector = Last::new();

assert!(collector.collect(1).is_continue());
assert!(collector.collect(2).is_continue());
assert!(collector.collect(3).is_continue());

assert_eq!(collector.finish(), Some(3));

use better_collect::{prelude::*, Last};

assert_eq!(Last::<i32>::new().finish(), None);

Implementations

impl<T> Last<T>

pub const fn new() -> Self

Creates an intance of this collector.

Trait Implementations

impl<T: Clone> Clone for Last<T>

fn clone(&self) -> Last<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Collector for Last<T>

type Item = T

Type of items this collector collects and accumulates.

type Output = Option<T>

The result this collector yields, via the finish method.

fn collect(&mut self, item: T) -> ControlFlow<()>

Collects an item and returns a ControlFlow indicating whether the collector has stopped accumulating right after this operation.

fn finish(self) -> Self::Output

Consumes the collector and returns the accumulated result.

fn collect_many( &mut self, items: impl IntoIterator<Item = Self::Item>, ) -> ControlFlow<()>

Collects items from an iterator and returns a ControlFlow indicating whether the collector has stopped collecting right after this operation.

fn collect_then_finish( self, items: impl IntoIterator<Item = Self::Item>, ) -> Self::Output

Collects items from an iterator, consumes the collector, and produces the accumulated result.

fn break_hint(&self) -> bool

Returns a hint whether the collector has stopped accumulating.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates a Collector that can “safely” collect items even after the underlying collector has stopped accumulating, without triggering undesired behaviors.

fn cloned(self) -> Cloning<Self>

where Self: Sized, Self::Item: Clone,

👎Deprecated since 0.3.0: Use cloning()

Use cloning().

fn cloning(self) -> Cloning<Self>

where Self: Sized, Self::Item: Clone,

Creates a RefCollector that clones every collected item.

fn copied(self) -> Copying<Self>

where Self: Sized, Self::Item: Copy,

👎Deprecated since 0.3.0: Use copying()

Use copying().

fn copying(self) -> Copying<Self>

where Self: Sized, Self::Item: Copy,

Creates a RefCollector that copies every collected item.

fn map<F, T>(self, f: F) -> Map<Self, T, F>

where Self: Sized, F: FnMut(T) -> Self::Item,

Creates a Collector that calls a closure on each item before collecting.

fn map_ref<F, T>(self, f: F) -> MapRef<Self, T, F>

where Self: Sized, F: FnMut(&mut T) -> Self::Item,

Creates a RefCollector that calls a closure on each item by mutable reference before collecting.

fn filter<F>(self, pred: F) -> Filter<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Creates a Collector that uses a closure to determine whether an item should be accumulated.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates a Collector that stops accumulating after collecting the first n items, or fewer if the underlying collector ends sooner.

fn take_while<F>(self, pred: F) -> TakeWhile<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Creates a Collector that accumulates items as long as a predicate returns true.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates a Collector that skips the first n collected items before it begins accumulating them.

fn chain<C>(self, other: C) -> Chain<Self, C::IntoCollector>

where Self: Sized, C: IntoCollector<Item = Self::Item>,

Creates a Collector that feeds every item in the first collector until it stops accumulating, then continues feeding items into the second one.

fn partition<C, F>( self, pred: F, other_if_false: C, ) -> Partition<Self, C::IntoCollector, F>

where Self: Sized, C: IntoCollector<Item = Self::Item>, F: FnMut(&mut Self::Item) -> bool,

Creates a Collector that distributes items between two collectors based on a predicate.

fn unzip<C>(self, other: C) -> Unzip<Self, C::IntoCollector>

where Self: Sized, C: IntoCollector,

Creates a Collector that destructures each 2-tuple (A, B) item and distributes its fields: A goes to the first collector, and B goes to the second collector.

fn unbatching<T, F>(self, f: F) -> Unbatching<Self, T, F>

where Self: Sized, F: FnMut(&mut Self, T) -> ControlFlow<()>,

Creates a Collector with a custom collection logic.

fn unbatching_ref<T, F>(self, f: F) -> UnbatchingRef<Self, T, F>

where Self: Sized, F: FnMut(&mut Self, &mut T) -> ControlFlow<()>,

Creates a RefCollector with a custom collection logic.

fn map_output<T, F>(self, f: F) -> MapOutput<Self, T, F>

where Self: Sized, F: FnOnce(Self::Output) -> T,

Creates a Collector that transforms the final accumulated result.

fn nest<C>(self, inner: C) -> Nest<Self, C::IntoCollector>

where Self: Collector<Item = C::Output> + Sized, C: IntoCollector<IntoCollector: Clone>,

Available on crate feature unstable only.

Creates a Collector that collects all outputs produced by an inner collector.

fn nest_exact<C>(self, inner: C) -> NestExact<Self, C::IntoCollector>

where Self: Collector<Item = C::Output> + Sized, C: IntoCollector<IntoCollector: Clone>,

Available on crate feature unstable only.

Creates a Collector that collects all outputs produced by an inner collector.

impl<T: Debug> Debug for Last<T>

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

Formats the value using the given formatter.

impl<T> Default for Last<T>

fn default() -> Self

Returns the “default value” for a type.