Trait SignalVec

pub trait SignalVec {
    type Item;

    // Required method
    fn poll_vec_change(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<VecDiff<Self::Item>>>;
}

Required Associated Types

type Item

Required Methods

fn poll_vec_change( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<VecDiff<Self::Item>>>

Implementations on Foreign Types

impl<'a, A> SignalVec for &'a mut A

where A: ?Sized + SignalVec + Unpin,

type Item = <A as SignalVec>::Item

fn poll_vec_change( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<VecDiff<Self::Item>>>

impl<A> SignalVec for Box<A>

where A: ?Sized + SignalVec + Unpin,

type Item = <A as SignalVec>::Item

fn poll_vec_change( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<VecDiff<Self::Item>>>

impl<A> SignalVec for Pin<A>

where A: Unpin + DerefMut, A::Target: SignalVec,

type Item = <<A as Deref>::Target as SignalVec>::Item

fn poll_vec_change( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<VecDiff<Self::Item>>>

Implementors

impl<A> SignalVec for Always<A>

type Item = A

impl<A> SignalVec for Enumerate<A>

where A: SignalVec,

type Item = (ReadOnlyMutable<Option<usize>>, <A as SignalVec>::Item)

impl<A> SignalVec for Flatten<A>

where A: SignalVec, A::Item: SignalVec,

type Item = <<A as SignalVec>::Item as SignalVec>::Item

impl<A> SignalVec for MutableSignalVec<A>

type Item = A

impl<A> SignalVec for SignalVecDebug<A>

where A: SignalVec, A::Item: Debug,

type Item = <A as SignalVec>::Item

impl<A, B> SignalVec for SignalSignalVec<A>

where A: Signal<Item = Vec<B>>,

type Item = B

impl<A, B> SignalVec for Chain<A, B>

where A: SignalVec, B: SignalVec<Item = A::Item>,

type Item = <A as SignalVec>::Item

impl<A, B, C> SignalVec for SwitchSignalVec<A, B, C>

where A: Signal, B: SignalVec, C: FnMut(A::Item) -> B,

type Item = <B as SignalVec>::Item

impl<A, B, F> SignalVec for FilterSignalCloned<A, B, F>

where A: SignalVec, A::Item: Clone, B: Signal<Item = bool>, F: FnMut(&A::Item) -> B,

type Item = <A as SignalVec>::Item

impl<A, B, F> SignalVec for Map<A, F>

where A: SignalVec, F: FnMut(A::Item) -> B,

type Item = B

impl<A, B, F> SignalVec for MapSignal<A, B, F>

where A: SignalVec, B: Signal, F: FnMut(A::Item) -> B,

type Item = <B as Signal>::Item

impl<A, F> SignalVec for Filter<A, F>

where A: SignalVec, F: FnMut(&A::Item) -> bool,

type Item = <A as SignalVec>::Item

impl<A, F> SignalVec for SortByCloned<A, F>

where A: SignalVec, F: FnMut(&A::Item, &A::Item) -> Ordering, A::Item: Clone,

type Item = <A as SignalVec>::Item

impl<K, V> SignalVec for MutableBTreeMapEntries<K, V>

where K: Ord + Clone,

type Item = (K, V)

impl<K, V> SignalVec for MutableBTreeMapKeys<K, V>

where K: Ord + Clone,

type Item = K

impl<S> SignalVec for StreamSignalVec<S>

where S: Stream,

type Item = <S as Stream>::Item

impl<S, A, F> SignalVec for DelayRemove<S, A, F>

where S: SignalVec, A: Future<Output = ()>, F: FnMut(&S::Item) -> A,

type Item = <S as SignalVec>::Item

impl<S, A, F> SignalVec for FilterMap<S, F>

where S: SignalVec, F: FnMut(S::Item) -> Option<A>,

type Item = A