Trait futures_signals::signal::Signal

pub trait Signal {
    type Item;

    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, Global>

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, 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>