Struct asyncplify::Dedup

#[must_use = "stream adaptors are lazy and do nothing unless consumed"]
pub struct Dedup<S> {
    // some fields omitted
}

Methods

impl<S> Dedup<S>

fn new(stream: S) -> Self

Trait Implementations

impl<S> Stream for Dedup<S> where S: Stream, S::Item: Clone + Eq

type Item = S::Item

fn consume<C>(self, consumer: C) where C: Consumer<Self::Item>

fn clonable(self) -> Clonable<Self> where Self: Sized, Self::Item: Clone

fn count(self) -> Count<Self> where Self: Sized

fn debounce<SC>(self, delay: Duration, scheduler: SC) -> Debounce<Self, SC> where SC: Scheduler, Self: Sized + 'static

fn dedup(self) -> Dedup<Self> where Self: Sized

fn dedup_by_key<F, K>(self, key_selector: F) -> DedupByKey<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> K

fn filter<F>(self, predicate: F) -> Filter<Self, F> where Self: Sized, F: FnMut(&mut Self::Item) -> bool

fn flat_map<F, SO>(self, func: F) -> Flatmap<Self, F> where Self: Sized, F: FnMut(Self::Item) -> SO, SO: Stream

fn fold<O, F>(self, initial: O, func: F) -> Fold<Self, F, O> where Self: Sized, F: FnMut(O, Self::Item) -> O

fn group_by<F, K>(self, key_selector: F) -> GroupBy<F, Self> where Self: Sized, F: FnMut(&Self::Item) -> K, K: Hash + Eq + Clone

fn inspect<F>(self, func: F) -> Inspect<Self, F> where F: FnMut(&mut Self::Item), Self: Sized

fn into_vec(self) -> Vec<Self::Item> where Self: Sized

fn last_value(self) -> Option<Self::Item> where Self: Sized

fn map<F, O>(self, func: F) -> Map<Self, F> where Self: Sized, F: FnMut(Self::Item) -> O

fn max(self) -> Max<Self> where Self: Sized

fn max_by_key<F, K>(self, f: F) -> MaxByKey<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> K, K: PartialOrd

fn min(self) -> Min<Self> where Self: Sized

fn min_by_key<F, K>(self, f: F) -> MinByKey<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> K, K: PartialOrd

fn observe_on_parallel<SC>(self, scheduler: SC) -> SyncToParallelObserveOn<Self, SC> where SC: ParallelScheduler, Self: Sized

fn scan<O, F>(self, initial: O, func: F) -> Scan<Self, F, O> where Self: Sized, F: FnMut(O, Self::Item) -> O, O: Clone

fn skip(self, count: u64) -> Skip<Self> where Self: Sized

fn skip_last(self, count: usize) -> SkipLast<Self> where Self: Sized

fn skip_until<U>(self, trigger: U) -> SkipUntil<Self, U> where Self: Sized, U: Stream

fn sort(self) -> Sort<Self> where Self: Sized

fn subscribe(self) where Self: Sized

fn subscribe_action<F>(self, action: F) where Self: Sized, F: FnMut(Self::Item)

fn subscribe_func<F>(self, predicate: F) where Self: Sized, F: FnMut(Self::Item) -> bool

fn sum(self) -> Sum<Self> where Self: Sized

fn take(self, count: u64) -> Take<Self> where Self: Sized

fn take_last(self, count: usize) -> TakeLast<Self> where Self: Sized

fn take_until<U>(self, trigger: U) -> TakeUntil<Self, U> where Self: Sized, U: Stream

fn to_vec<F>(self, splitter: F) -> ToVec<Self, F> where F: FnMut(&Vec<Self::Item>) -> bool, Self: Sized

fn unique(self) -> Unique<Self> where Self: Sized

fn unique_by_key<F, K>(self, key_selector: F) -> UniqueByKey<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> K, K: Eq + Hash

fn zip<R>(self, right: R) -> Zip<Self, R> where Self: Sized