Trait StreamTupleExt 

pub trait StreamTupleExt<I, S>: IntoStreamTuple<I, Output = S> + Sized
where
    I: Id,
{
    // Provided methods
    fn join(self) -> Stream<I, S::Item>
       where S: IntoJoin<I, All> { ... }
    fn join_filter<F>(self, f: F) -> Stream<I, S::Item>
       where S: IntoJoinFilter<I, All>,
             F: FilterFn<I, Splat<S::Item>> + Clone { ... }
    fn join_filter_map<F, U>(self, f: F) -> Stream<I, U>
       where S: IntoJoinFilterMap<I, All>,
             F: FilterMapFn<I, Splat<S::Item>, U> + Clone,
             U: Value { ... }
    fn join_map<F, U>(self, f: F) -> Stream<I, U>
       where S: IntoJoinMap<I, All>,
             F: MapFn<I, Splat<S::Item>, U> + Clone,
             U: Value { ... }
    fn left_join(self) -> Stream<I, S::Item>
       where S: IntoJoin<I, First> { ... }
    fn left_join_filter<F>(self, f: F) -> Stream<I, S::Item>
       where S: IntoJoinFilter<I, First>,
             F: FilterFn<I, Splat<S::Item>> + Clone { ... }
    fn left_join_filter_map<F, U>(self, f: F) -> Stream<I, U>
       where S: IntoJoinFilterMap<I, First>,
             F: FilterMapFn<I, Splat<S::Item>, U> + Clone,
             U: Value { ... }
    fn left_join_map<F, U>(self, f: F) -> Stream<I, U>
       where S: IntoJoinMap<I, First>,
             F: MapFn<I, Splat<S::Item>, U> + Clone,
             U: Value { ... }
    fn full_join(self) -> Stream<I, S::Item>
       where S: IntoJoin<I, Any> { ... }
    fn full_join_filter<F>(self, f: F) -> Stream<I, S::Item>
       where S: IntoJoinFilter<I, Any>,
             F: FilterFn<I, Splat<S::Item>> + Clone { ... }
    fn full_join_filter_map<F, U>(self, f: F) -> Stream<I, U>
       where S: IntoJoinFilterMap<I, Any>,
             F: FilterMapFn<I, Splat<S::Item>, U> + Clone,
             U: Value { ... }
    fn full_join_map<F, U>(self, f: F) -> Stream<I, U>
       where S: IntoJoinMap<I, Any>,
             F: MapFn<I, Splat<S::Item>, U> + Clone,
             U: Value { ... }
}

Extension of StreamTuple.

While conceptually, this extension trait does belong to StreamTuple, allowing to conveniently work with data types that can be converted into a tuple of streams, it is deliberately implemented for anything that converts via IntoStreamTuple, as this offers more flexibilty.

Provided Methods

fn join(self) -> Stream<I, S::Item>

where S: IntoJoin<I, All>,

fn join_filter<F>(self, f: F) -> Stream<I, S::Item>

where S: IntoJoinFilter<I, All>, F: FilterFn<I, Splat<S::Item>> + Clone,

fn join_filter_map<F, U>(self, f: F) -> Stream<I, U>

where S: IntoJoinFilterMap<I, All>, F: FilterMapFn<I, Splat<S::Item>, U> + Clone, U: Value,

fn join_map<F, U>(self, f: F) -> Stream<I, U>

where S: IntoJoinMap<I, All>, F: MapFn<I, Splat<S::Item>, U> + Clone, U: Value,

fn left_join(self) -> Stream<I, S::Item>

where S: IntoJoin<I, First>,

fn left_join_filter<F>(self, f: F) -> Stream<I, S::Item>

where S: IntoJoinFilter<I, First>, F: FilterFn<I, Splat<S::Item>> + Clone,

fn left_join_filter_map<F, U>(self, f: F) -> Stream<I, U>

where S: IntoJoinFilterMap<I, First>, F: FilterMapFn<I, Splat<S::Item>, U> + Clone, U: Value,

fn left_join_map<F, U>(self, f: F) -> Stream<I, U>

where S: IntoJoinMap<I, First>, F: MapFn<I, Splat<S::Item>, U> + Clone, U: Value,

fn full_join(self) -> Stream<I, S::Item>

where S: IntoJoin<I, Any>,

fn full_join_filter<F>(self, f: F) -> Stream<I, S::Item>

where S: IntoJoinFilter<I, Any>, F: FilterFn<I, Splat<S::Item>> + Clone,

fn full_join_filter_map<F, U>(self, f: F) -> Stream<I, U>

where S: IntoJoinFilterMap<I, Any>, F: FilterMapFn<I, Splat<S::Item>, U> + Clone, U: Value,

fn full_join_map<F, U>(self, f: F) -> Stream<I, U>

where S: IntoJoinMap<I, Any>, F: MapFn<I, Splat<S::Item>, U> + Clone, U: Value,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, I, S> StreamTupleExt<I, S> for T

where I: Id, T: IntoStreamTuple<I, Output = S>,