Enum tinychain::stream::TCStream

pub enum TCStream {
    Aggregate(Box<Aggregate>),
    Collection(Collection),
    Filter(Box<Filter>),
    Flatten(Box<Flatten>),
    Map(Box<Map>),
    Range(Range),
}

A stream generator such as a Collection or a mapping or aggregation of its items

Variants

Aggregate(Box<Aggregate>)

Collection(Collection)

Filter(Box<Filter>)

Flatten(Box<Flatten>)

Map(Box<Map>)

Range(Range)

Implementations

impl TCStream

pub fn aggregate(self) -> Self

Group equal sequential items in this stream.

For example, aggregating the stream ['b', 'b', 'a', 'a', 'b'] will produce ['b', 'a', 'b'].

pub fn filter(self, filter: Closure) -> Self

Return a new stream with only the elements in this stream which match the given filter.

pub fn flatten(self) -> Self

Flatten a stream of streams into a stream of States.

pub async fn fold(
    self,
    txn: Txn,
    item_name: Id,
    state: Map<State>,
    op: Closure
) -> TCResult<State>

Fold this stream with the given initial State and Closure.

For example, folding [1, 2, 3] with 0 and Number::add will produce 6.

pub async fn for_each(self, txn: &Txn, op: Closure) -> TCResult<()>

Execute the given Closure with each item in the stream as its args.

pub async fn hash(self, txn: Txn) -> TCResult<Output<Sha256>>

Compute the SHA256 hash of this TCStream.

pub fn map(self, op: Closure) -> Self

Return a TCStream produced by calling the given Closure on each item in this stream.

pub fn range(start: Number, stop: Number, step: Number) -> Self

Return a TCStream of numbers at the given step within the given range.

Trait Implementations

impl Clone for TCStream

fn clone(&self) -> TCStream

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> From<T> for TCStream where
    Collection: From<T>, 

fn from(collection: T) -> Self

Converts to this type from the input type.

impl From<TCStream> for State

fn from(stream: TCStream) -> Self

Converts to this type from the input type.

impl<'en> IntoView<'en, Dir> for TCStream

type Txn = Txn

type View = SeqStream<Result<StateView<'en>, TCError>, Pin<Box<dyn Stream<Item = Result<StateView<'en>, TCError>> + Unpin + Send + 'en, Global>>>

fn into_view<'async_trait>(
    self,
    txn: Self::Txn
) -> Pin<Box<dyn Future<Output = TCResult<Self::View>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Return a View which can be encoded with en::IntoStream.

impl Source for TCStream

fn into_stream<'async_trait>(
    self,
    txn: Txn
) -> Pin<Box<dyn Future<Output = TCResult<TCBoxTryStream<'static, State>>> + Send + 'async_trait>> where
    Self: 'async_trait, 

impl TryCastFrom<State> for TCStream

fn can_cast_from(state: &State) -> bool

Test if value can be cast into Self.

fn opt_cast_from(state: State) -> Option<Self>

Returns Some(Self) if the source value can be cast into Self, otherwise None.

fn try_cast_from<Err, OnErr>(value: T, on_err: OnErr) -> Result<Self, Err> where
    OnErr: FnOnce(&T) -> Err, 

Returns Ok(Self) if the source value can be cast into Self, otherwise calls on_err.