Struct StreamBuilder 

pub struct StreamBuilder<Effect, Event, Task> { /* private fields */ }

A builder of stream command

Implementations

impl<Effect, Event, Task, T> StreamBuilder<Effect, Event, Task>

where Effect: Send + 'static, Event: Send + 'static, Task: Stream<Item = T> + Send + 'static,

pub fn new<F>(make_task: F) -> Self

where F: FnOnce(CommandContext<Effect, Event>) -> Task + Send + 'static,

pub fn map<F, U>( self, map: F, ) -> StreamBuilder<Effect, Event, impl Stream<Item = U>>

where F: FnMut(T) -> U + Send + 'static,

pub fn then_request<F, U, NextTask>( self, make_next_builder: F, ) -> StreamBuilder<Effect, Event, impl Stream<Item = U>>

where F: Fn(T) -> RequestBuilder<Effect, Event, NextTask> + Send + 'static, NextTask: Future<Output = U> + Send + 'static,

Chain a RequestBuilder to run after completion of this StreamBuilder, passing the result to the provided closure make_next_builder.

The returned value of the closure must be a RequestBuilder, which can represent some more work to be done before the composed future is finished.

If you want to chain a subscription, use Self::then_stream instead.

The closure make_next_builder is only run after successful completion of the self future.

Note that this function consumes the receiving StreamBuilder and returns a new one that represents the composition.

Example

let mut cmd: Command<Effect, Event> = Command::stream_from_shell(AnOperation::More(1))
    .then_request(|first| {
        let AnOperationOutput::Other(first) = first else {
            panic!("Invalid output!")
        };

        let second = first + 1;
        Command::request_from_shell(AnOperation::More(second))
    })
    .then_send(Event::Completed);

let Effect::AnEffect(mut request) = cmd.effects().next().unwrap();
assert_eq!(request.operation, AnOperation::More(1));

request
   .resolve(AnOperationOutput::Other(1))
   .expect("to resolve");

let Effect::AnEffect(mut request) = cmd.effects().next().unwrap();
assert_eq!(request.operation, AnOperation::More(2));

pub fn then_stream<F, U, NextTask>( self, make_next_builder: F, ) -> StreamBuilder<Effect, Event, impl Stream<Item = U>>

where F: Fn(T) -> StreamBuilder<Effect, Event, NextTask> + Send + 'static, NextTask: Stream<Item = U> + Send + 'static,

Chain another StreamBuilder to run after completion of this one, passing the result to the provided closure make_next_builder.

The returned value of the closure must be a StreamBuilder, which can represent some more work to be done before the composed future is finished.

If you want to chain a request, use Self::then_request instead.

The closure make_next_builder is only run after successful completion of the self future.

Note that this function consumes the receiving StreamBuilder and returns a new one that represents the composition.

Example

let mut cmd: Command<Effect, Event> = Command::stream_from_shell(AnOperation::More(1))
   .then_stream(|first| {
      let AnOperationOutput::Other(first) = first else {
         panic!("Invalid output!")
     };

     let second = first + 1;
     Command::stream_from_shell(AnOperation::More(second))
   })
   .then_send(Event::Completed);

let Effect::AnEffect(mut request) = cmd.effects().next().unwrap();
assert_eq!(request.operation, AnOperation::More(1));

request
  .resolve(AnOperationOutput::Other(1))
  .expect("to resolve");

let Effect::AnEffect(mut request) = cmd.effects().next().unwrap();
assert_eq!(request.operation, AnOperation::More(2));

pub fn then_send<E>(self, event: E) -> Command<Effect, Event>

where E: Fn(T) -> Event + Send + 'static,

Create the command in an evented context

pub fn into_stream(self, ctx: CommandContext<Effect, Event>) -> Task

Convert the StreamBuilder into a stream to use in an async context

pub fn build(self) -> Command<Effect, Event>

Convert the StreamBuilder into a Command to use in an sync context

Note: You might be looking for then_send instead, which will send each item in the stream back into the app with an event.

The command created in this function will ignore the output of the stream so may not be very useful. It may be useful when using a 3rd party capability and you don’t care about the stream output.