Trait Signal

pub trait Signal {
    type Item;

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

Required Associated Types

type Item

Required Methods

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

Implementations on Foreign Types

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

where A: ?Sized + Signal + Unpin,

type Item = <A as Signal>::Item

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

impl<A> Signal for Box<A>

where A: ?Sized + Signal + Unpin,

type Item = <A as Signal>::Item

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

impl<A> Signal for Pin<A>

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

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

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

Implementors

impl<A> Signal for IsEmpty<A>

where A: SignalVec,

type Item = bool

impl<A> Signal for Len<A>

where A: SignalVec,

type Item = usize

impl<A> Signal for SumSignal<A>

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

type Item = <A as SignalVec>::Item

impl<A> Signal for ToSignalCloned<A>

where A: SignalVec,

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

impl<A> Signal for Always<A>

type Item = A

impl<A> Signal for BroadcasterSignal<A>

where A: Signal, A::Item: Copy,

type Item = <A as Signal>::Item

impl<A> Signal for BroadcasterSignalCloned<A>

where A: Signal, A::Item: Clone,

type Item = <A as Signal>::Item

impl<A> Signal for Dedupe<A>

where A: Signal, A::Item: PartialEq + Copy,

type Item = <A as Signal>::Item

impl<A> Signal for DedupeCloned<A>

where A: Signal, A::Item: PartialEq + Clone,

type Item = <A as Signal>::Item

impl<A> Signal for Eq<A>

where A: Signal, A::Item: PartialEq,

type Item = bool

impl<A> Signal for First<A>

where A: Signal,

type Item = <A as Signal>::Item

impl<A> Signal for Flatten<A>

where A: Signal, A::Item: Signal,

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

impl<A> Signal for FromFuture<A>

where A: Future,

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

impl<A> Signal for FromStream<A>

where A: Stream,

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

impl<A> Signal for Neq<A>

where A: Signal, A::Item: PartialEq,

type Item = bool

impl<A> Signal for Receiver<A>

type Item = A

impl<A> Signal for SignalDebug<A>

where A: Signal, A::Item: Debug,

type Item = <A as Signal>::Item

impl<A, B> Signal for Inspect<A, B>

where A: Signal, B: FnMut(&A::Item),

type Item = <A as Signal>::Item

impl<A, B> Signal for StopIf<A, B>

where A: Signal, B: FnMut(&A::Item) -> bool,

type Item = <A as Signal>::Item

impl<A, B, C> Signal for DedupeMap<A, B>

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

type Item = C

impl<A, B, C> Signal for FilterMap<A, B>

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

type Item = Option<C>

impl<A, B, C> Signal for Map<A, B>

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

type Item = C

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>

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

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

impl<A, B, F> Signal for ToSignalMap<A, F>

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

type Item = B

impl<A, B, F> Signal for BroadcasterSignalRef<A, F>

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

type Item = B

impl<A, B, F> Signal for MutableSignalRef<A, F>

where F: FnMut(&A) -> B,

type Item = B

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

type Item = A

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

type Item = A

impl<M> Signal for MapWatchKeySignal<M>

where M: SignalMap, M::Key: PartialEq, M::Value: Clone,

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

impl<S> Signal for OptionSignal<S>

where S: Signal,

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

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

where S: Signal,

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