pub trait Signal {
    type Item;

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

Required Associated Types§

Required Methods§

source

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

Implementations on Foreign Types§

source§

impl<'a, A> Signal for &'a mut Awhere A: ?Sized + Signal + Unpin,

§

type Item = <A as Signal>::Item

source§

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

source§

impl<A> Signal for Box<A>where A: ?Sized + Signal + Unpin,

§

type Item = <A as Signal>::Item

source§

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

source§

impl<A> Signal for Pin<A>where A: Unpin + DerefMut, A::Target: Signal,

§

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

source§

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

Implementors§

source§

impl<A> Signal for IsEmpty<A>where A: SignalVec,

§

type Item = bool

source§

impl<A> Signal for Len<A>where A: SignalVec,

§

type Item = usize

source§

impl<A> Signal for SumSignal<A>where A: SignalVec, A::Item: for<'a> Sum<&'a A::Item>,

§

type Item = <A as SignalVec>::Item

source§

impl<A> Signal for ToSignalCloned<A>where A: SignalVec,

§

type Item = Vec<<A as SignalVec>::Item, Global>

source§

impl<A> Signal for Always<A>

§

type Item = A

source§

impl<A> Signal for BroadcasterSignal<A>where A: Signal, A::Item: Copy,

§

type Item = <A as Signal>::Item

source§

impl<A> Signal for BroadcasterSignalCloned<A>where A: Signal, A::Item: Clone,

§

type Item = <A as Signal>::Item

source§

impl<A> Signal for Dedupe<A>where A: Signal, A::Item: PartialEq + Copy,

§

type Item = <A as Signal>::Item

source§

impl<A> Signal for DedupeCloned<A>where A: Signal, A::Item: PartialEq + Clone,

§

type Item = <A as Signal>::Item

source§

impl<A> Signal for Eq<A>where A: Signal, A::Item: PartialEq,

§

type Item = bool

source§

impl<A> Signal for First<A>where A: Signal,

§

type Item = <A as Signal>::Item

source§

impl<A> Signal for Flatten<A>where A: Signal, A::Item: Signal,

§

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

source§

impl<A> Signal for FromFuture<A>where A: Future,

§

type Item = Option<<A as Future>::Output>

source§

impl<A> Signal for FromStream<A>where A: Stream,

§

type Item = Option<<A as Stream>::Item>

source§

impl<A> Signal for Neq<A>where A: Signal, A::Item: PartialEq,

§

type Item = bool

source§

impl<A> Signal for Receiver<A>

§

type Item = A

source§

impl<A> Signal for SignalDebug<A>where A: Signal, A::Item: Debug,

§

type Item = <A as Signal>::Item

source§

impl<A, B> Signal for Inspect<A, B>where A: Signal, B: FnMut(&A::Item),

§

type Item = <A as Signal>::Item

source§

impl<A, B, C> Signal for DedupeMap<A, B>where A: Signal, A::Item: PartialEq, B: FnMut(&mut A::Item) -> C,

§

type Item = C

source§

impl<A, B, C> Signal for FilterMap<A, B>where A: Signal, B: FnMut(A::Item) -> Option<C>,

§

type Item = Option<C>

source§

impl<A, B, C> Signal for Map<A, B>where A: Signal, B: FnMut(A::Item) -> C,

§

type Item = C

source§

impl<A, B, C> Signal for MapFuture<A, B, C>where A: Signal, B: Future, C: FnMut(A::Item) -> B,

§

type Item = Option<<B as Future>::Output>

source§

impl<A, B, C> Signal for Switch<A, B, C>where A: Signal, B: Signal, C: FnMut(A::Item) -> B,

§

type Item = <B as Signal>::Item

source§

impl<A, B, C> Signal for Throttle<A, B, C>where A: Signal, B: Future<Output = ()>, C: FnMut() -> B,

§

type Item = <A as Signal>::Item

source§

impl<A, B, F> Signal for ToSignalMap<A, F>where A: SignalVec, F: FnMut(&[A::Item]) -> B,

§

type Item = B

source§

impl<A, B, F> Signal for BroadcasterSignalRef<A, F>where A: Signal, F: FnMut(&A::Item) -> B,

§

type Item = B

source§

impl<A, B, F> Signal for MutableSignalRef<A, F>where F: FnMut(&A) -> B,

§

type Item = B

source§

impl<A: Clone> Signal for MutableSignalCloned<A>

§

type Item = A

source§

impl<A: Copy> Signal for MutableSignal<A>

§

type Item = A

source§

impl<M> Signal for MapWatchKeySignal<M>where M: SignalMap, M::Key: PartialEq, M::Value: Clone,

§

type Item = Option<<M as SignalMap>::Value>

source§

impl<S> Signal for OptionSignal<S>where S: Signal,

§

type Item = Option<<S as Signal>::Item>

source§

impl<S, E> Signal for ResultSignal<S, E>where S: Signal,

§

type Item = Result<<S as Signal>::Item, E>