Trait silkenweb::prelude::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: Signal + Unpin + ?Sized,

type Item = <A as Signal>::Item

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

impl<A> Signal for Box<A>

where A: Signal + Unpin + ?Sized,

type Item = <A as Signal>::Item

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

impl<A> Signal for Pin<A>

where A: Unpin + DerefMut, <A as Deref>::Target: Signal,

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

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

impl<S0, S1, Output, F> Signal for Map2<S0, S1, F>

where S0: Signal, S1: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map2<S0, S1, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map2<S0, S1, F> as Signal>::Item>>

impl<S0, S1, S2, Output, F> Signal for Map3<S0, S1, S2, F>

where S0: Signal, S1: Signal, S2: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map3<S0, S1, S2, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map3<S0, S1, S2, F> as Signal>::Item>>

impl<S0, S1, S2, S3, Output, F> Signal for Map4<S0, S1, S2, S3, F>

where S0: Signal, S1: Signal, S2: Signal, S3: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item, &<S3 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map4<S0, S1, S2, S3, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map4<S0, S1, S2, S3, F> as Signal>::Item>>

impl<S0, S1, S2, S3, S4, Output, F> Signal for Map5<S0, S1, S2, S3, S4, F>

where S0: Signal, S1: Signal, S2: Signal, S3: Signal, S4: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item, &<S3 as Signal>::Item, &<S4 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map5<S0, S1, S2, S3, S4, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map5<S0, S1, S2, S3, S4, F> as Signal>::Item>>

impl<S0, S1, S2, S3, S4, S5, Output, F> Signal for Map6<S0, S1, S2, S3, S4, S5, F>

where S0: Signal, S1: Signal, S2: Signal, S3: Signal, S4: Signal, S5: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item, &<S3 as Signal>::Item, &<S4 as Signal>::Item, &<S5 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map6<S0, S1, S2, S3, S4, S5, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map6<S0, S1, S2, S3, S4, S5, F> as Signal>::Item>>

impl<S0, S1, S2, S3, S4, S5, S6, Output, F> Signal for Map7<S0, S1, S2, S3, S4, S5, S6, F>

where S0: Signal, S1: Signal, S2: Signal, S3: Signal, S4: Signal, S5: Signal, S6: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item, &<S3 as Signal>::Item, &<S4 as Signal>::Item, &<S5 as Signal>::Item, &<S6 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map7<S0, S1, S2, S3, S4, S5, S6, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map7<S0, S1, S2, S3, S4, S5, S6, F> as Signal>::Item>>

impl<S0, S1, S2, S3, S4, S5, S6, S7, Output, F> Signal for Map8<S0, S1, S2, S3, S4, S5, S6, S7, F>

where S0: Signal, S1: Signal, S2: Signal, S3: Signal, S4: Signal, S5: Signal, S6: Signal, S7: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item, &<S3 as Signal>::Item, &<S4 as Signal>::Item, &<S5 as Signal>::Item, &<S6 as Signal>::Item, &<S7 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map8<S0, S1, S2, S3, S4, S5, S6, S7, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map8<S0, S1, S2, S3, S4, S5, S6, S7, F> as Signal>::Item>>

impl<S0, S1, S2, S3, S4, S5, S6, S7, S8, Output, F> Signal for Map9<S0, S1, S2, S3, S4, S5, S6, S7, S8, F>

where S0: Signal, S1: Signal, S2: Signal, S3: Signal, S4: Signal, S5: Signal, S6: Signal, S7: Signal, S8: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item, &<S3 as Signal>::Item, &<S4 as Signal>::Item, &<S5 as Signal>::Item, &<S6 as Signal>::Item, &<S7 as Signal>::Item, &<S8 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map9<S0, S1, S2, S3, S4, S5, S6, S7, S8, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map9<S0, S1, S2, S3, S4, S5, S6, S7, S8, F> as Signal>::Item>>

impl<S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, Output, F> Signal for Map10<S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, F>

where S0: Signal, S1: Signal, S2: Signal, S3: Signal, S4: Signal, S5: Signal, S6: Signal, S7: Signal, S8: Signal, S9: Signal, F: FnMut(&<S0 as Signal>::Item, &<S1 as Signal>::Item, &<S2 as Signal>::Item, &<S3 as Signal>::Item, &<S4 as Signal>::Item, &<S5 as Signal>::Item, &<S6 as Signal>::Item, &<S7 as Signal>::Item, &<S8 as Signal>::Item, &<S9 as Signal>::Item) -> Output,

type Item = Output

fn poll_change( self: Pin<&mut Map10<S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, F>>, cx: &mut Context<'_> ) -> Poll<Option<<Map10<S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, F> as Signal>::Item>>

Implementors

impl<A> Signal for BroadcasterSignal<A>

where A: Signal, <A as Signal>::Item: Copy,

type Item = <A as Signal>::Item

impl<A> Signal for BroadcasterSignalCloned<A>

where A: Signal, <A as Signal>::Item: Clone,

type Item = <A as Signal>::Item

impl<A> Signal for Receiver<A>

type Item = A

impl<A> Signal for MutableSignal<A>

where A: Copy,

type Item = A

impl<A> Signal for MutableSignalCloned<A>

where A: Clone,

type Item = A

impl<A> Signal for Always<A>

type Item = A

impl<A> Signal for Dedupe<A>

where A: Signal, <A as Signal>::Item: PartialEq + Copy,

type Item = <A as Signal>::Item

impl<A> Signal for DedupeCloned<A>

where A: Signal, <A as Signal>::Item: PartialEq + Clone,

type Item = <A as Signal>::Item

impl<A> Signal for Eq<A>

where A: Signal, <A as Signal>::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 as Signal>::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 as Signal>::Item: PartialEq,

type Item = bool

impl<A> Signal for SignalDebug<A>

where A: Signal, <A as Signal>::Item: Debug,

type Item = <A as Signal>::Item

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 as SignalVec>::Item: for<'a> Sum<&'a <A as SignalVec>::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, B> Signal for Inspect<A, B>

where A: Signal, B: FnMut(&<A as Signal>::Item),

type Item = <A as Signal>::Item

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

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

type Item = <A as Signal>::Item

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

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

type Item = C

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

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

type Item = Option<C>

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

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

type Item = C

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

where A: Signal, B: Future, C: FnMut(<A as Signal>::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 as Signal>::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 BroadcasterSignalRef<A, F>

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

type Item = B

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

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

type Item = B

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

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

type Item = B

impl<M> Signal for MapWatchKeySignal<M>

where M: SignalMap, <M as SignalMap>::Key: PartialEq, <M as SignalMap>::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>