Struct sodium_rust::Stream

pub struct Stream<A> {
    pub impl_: StreamImpl<A>,
}

Fields

impl_: StreamImpl<A>

Implementations

impl<A: Clone + Send + 'static> Stream<Option<A>>

pub fn filter_option(&self) -> Stream<A>

impl<'a, A: Clone + Send + Sync + 'static, COLLECTION: IntoIterator<Item = A> + Clone + Send + 'static> Stream<COLLECTION>

pub fn split(&self) -> Stream<A>

impl<A: Clone + Send + 'static> Stream<A>

pub fn new(sodium_ctx: &SodiumCtx) -> Stream<A>

pub fn to_dep(&self) -> Dep

pub fn snapshot<B: Clone + Send + 'static, C: Clone + Send + 'static, FN: IsLambda2<A, B, C> + Send + Sync + 'static>(
    &self,
    cb: &Cell<B>,
    f: FN
) -> Stream<C>

pub fn snapshot1<B: Send + Clone + 'static>(&self, cb: &Cell<B>) -> Stream<B>

pub fn snapshot3<B: Send + Clone + 'static, C: Send + Clone + 'static, D: Send + Clone + 'static, FN: IsLambda3<A, B, C, D> + Send + Sync + 'static>(
    &self,
    cb: &Cell<B>,
    cc: &Cell<C>,
    f: FN
) -> Stream<D>

pub fn snapshot4<B: Send + Clone + 'static, C: Send + Clone + 'static, D: Send + Clone + 'static, E: Send + Clone + 'static, FN: IsLambda4<A, B, C, D, E> + Send + Sync + 'static>(
    &self,
    cb: &Cell<B>,
    cc: &Cell<C>,
    cd: &Cell<D>,
    f: FN
) -> Stream<E>

pub fn snapshot5<B: Send + Clone + 'static, C: Send + Clone + 'static, D: Send + Clone + 'static, E: Send + Clone + 'static, F: Send + Clone + 'static, FN: IsLambda5<A, B, C, D, E, F> + Send + Sync + 'static>(
    &self,
    cb: &Cell<B>,
    cc: &Cell<C>,
    cd: &Cell<D>,
    ce: &Cell<E>,
    f: FN
) -> Stream<F>

pub fn snapshot6<B: Send + Clone + 'static, C: Send + Clone + 'static, D: Send + Clone + 'static, E: Send + Clone + 'static, F: Send + Clone + 'static, G: Send + Clone + 'static, FN: IsLambda6<A, B, C, D, E, F, G> + Send + Sync + 'static>(
    &self,
    cb: &Cell<B>,
    cc: &Cell<C>,
    cd: &Cell<D>,
    ce: &Cell<E>,
    cf: &Cell<F>,
    f: FN
) -> Stream<G>

pub fn map<B: Send + Clone + 'static, FN: IsLambda1<A, B> + Send + Sync + 'static>(
    &self,
    f: FN
) -> Stream<B>

pub fn map_to<B: Send + Sync + Clone + 'static>(&self, b: B) -> Stream<B>

pub fn filter<PRED: IsLambda1<A, bool> + Send + Sync + 'static>(
    &self,
    pred: PRED
) -> Stream<A>

pub fn or_else(&self, s2: &Stream<A>) -> Stream<A>

pub fn merge<FN: IsLambda2<A, A, A> + Send + Sync + 'static>(
    &self,
    s2: &Stream<A>,
    f: FN
) -> Stream<A>

pub fn hold(&self, a: A) -> Cell<A>

pub fn hold_lazy(&self, a: Lazy<A>) -> Cell<A>

pub fn gate(&self, cpred: &Cell<bool>) -> Stream<A>

pub fn once(&self) -> Stream<A>

pub fn collect<B, S, F>(&self, init_state: S, f: F) -> Stream<B> where
    B: Send + Clone + 'static,
    S: Send + Clone + 'static,
    F: IsLambda2<A, S, (B, S)> + Send + Sync + 'static, 

pub fn collect_lazy<B, S, F>(&self, init_state: Lazy<S>, f: F) -> Stream<B> where
    B: Send + Clone + 'static,
    S: Send + Clone + 'static,
    F: IsLambda2<A, S, (B, S)> + Send + Sync + 'static, 

pub fn accum<S, F>(&self, init_state: S, f: F) -> Cell<S> where
    S: Send + Clone + 'static,
    F: IsLambda2<A, S, S> + Send + Sync + 'static, 

pub fn accum_lazy<S, F>(&self, init_state: Lazy<S>, f: F) -> Cell<S> where
    S: Send + Clone + 'static,
    F: IsLambda2<A, S, S> + Send + Sync + 'static, 

pub fn listen_weak<K: IsLambda1<A, ()> + Send + Sync + 'static>(
    &self,
    k: K
) -> Listener

pub fn listen<K: IsLambda1<A, ()> + Send + Sync + 'static>(
    &self,
    k: K
) -> Listener

Trait Implementations

impl<A> Clone for Stream<A>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.