Struct Command

Source
pub struct Command<Effect, Event> { /* private fields */ }

Implementations§

Source§

impl<Effect, Event> Command<Effect, Event>

Source

pub fn was_aborted(&self) -> bool

Source§

impl<Effect, Event> Command<Effect, Event>
where Effect: Send + 'static, Event: Send + 'static,

Source

pub fn new<F, Fut>(create_task: F) -> Self
where F: FnOnce(CommandContext<Effect, Event>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Create a new command orchestrating effects with async Rust. This is the lowest level API to create a Command if you need full control over its execution. In most cases you will more likely want to create Commands with capabilities, and using the combinator APIs (and and all) to orchestrate them.

The create_task closure receives a CommandContext that it can use to send shell requests, events back to the app, and to spawn additional tasks. The closure is expected to return a future which becomes the command’s main asynchronous task.

§Panics

If we could not make the task ready because the ready channel was disconnected.

Source

pub fn done() -> Self

Create an empty, completed Command. This is useful as a return value from update if there are no side-effects to perform.

Source

pub fn from<Ef, Ev>(subcmd: Command<Ef, Ev>) -> Self
where Ef: Send + 'static + Into<Effect> + Unpin, Ev: Send + 'static + Into<Event> + Unpin, Effect: Unpin, Event: Unpin,

Create a command from another command with compatible Effect and Event types

Source

pub fn into<Ef, Ev>(self) -> Command<Ef, Ev>
where Ef: Send + 'static + Unpin, Ev: Send + 'static + Unpin, Effect: Unpin + Into<Ef>, Event: Unpin + Into<Ev>,

Turn the command into another command with compatible Effect and Event types

Source

pub fn event(event: Event) -> Self

Create a Command which dispatches an event and terminates. This is an alternative to calling update recursively. The only difference is that the two update calls will be visible to Crux and can show up in logs or any tooling. The trade-off is that the event is not guaranteed to dispatch instantly - another update call which is already scheduled may happen first.

Source

pub fn notify_shell<Op>( operation: Op, ) -> NotificationBuilder<Effect, Event, impl Future<Output = ()>>
where Op: Operation, Effect: From<Request<Op>>,

Start a creation of a Command which sends a notification to the shell with a provided operation.

Returns a NotificationBuilder which can be converted into a Command directly.

In an async context, NotificationBuilder can be turned into a future that resolves to the operation output type.

Source

pub fn request_from_shell<Op>( operation: Op, ) -> RequestBuilder<Effect, Event, impl Future<Output = Op::Output>>
where Op: Operation, Effect: From<Request<Op>>,

Start a creation of a Command which sends a one-time request to the shell with a provided operation.

Returns a RequestBuilder, which can be converted into a Command directly, or chained with another command builder using .then.

In an async context, RequestBuilder can be turned into a future that resolves to the operation output type.

Source

pub fn stream_from_shell<Op>( operation: Op, ) -> StreamBuilder<Effect, Event, impl Stream<Item = Op::Output>>
where Op: Operation, Effect: From<Request<Op>>,

Start a creation of a Command which sends a stream request to the shell with a provided operation.

Returns a StreamBuilder, which can be converted into a Command directly, or chained with a RequestBuilder builder using .then.

In an async context, StreamBuilder can be turned into a stream that with the operation output type as item.

Source

pub fn is_done(&mut self) -> bool

Run the effect state machine until it settles, then return true if there is any more work to do - tasks to run or events or effects to receive

Source

pub fn effects(&mut self) -> impl Iterator<Item = Effect> + '_

Run the effect state machine until it settles and return an iterator over the effects

Source

pub fn events(&mut self) -> impl Iterator<Item = Event> + '_

Run the effect state machine until it settles and return an iterator over the events

Source

pub fn then(self, other: Self) -> Self
where Effect: Unpin, Event: Unpin,

Create a command running self and the other command in sequence

Source

pub fn and(self, other: Self) -> Self
where Effect: Unpin, Event: Unpin,

Convenience for Command::all which runs another command concurrently with this one

Source

pub fn all<I>(commands: I) -> Self
where I: IntoIterator<Item = Self>, Effect: Unpin, Event: Unpin,

Create a command running a number of commands concurrently

Source

pub fn map_effect<F, NewEffect>(self, map: F) -> Command<NewEffect, Event>
where F: Fn(Effect) -> NewEffect + Send + Sync + 'static, NewEffect: Send + Unpin + 'static, Effect: Unpin, Event: Unpin,

Map effects requested as part of this command to a different effect type.

This is useful when composing apps to convert a command from a child app to a command of the parent app.

Source

pub fn map_event<F, NewEvent>(self, map: F) -> Command<Effect, NewEvent>
where F: Fn(Event) -> NewEvent + Send + Sync + 'static, NewEvent: Send + Unpin + 'static, Effect: Unpin, Event: Unpin,

Map events sent as part of this command to a different effect type

This is useful when composing apps to convert a command from a child app to a command of the parent app.

Source

pub fn spawn<F, Fut>(&mut self, create_task: F)
where F: FnOnce(CommandContext<Effect, Event>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawn an additional task on the command. The task will execute concurrently with existing tasks

The create_task closure receives a CommandContext that it can use to send shell requests, events back to the app, and to spawn additional tasks. The closure is expected to return a future.

Source

pub fn abort_handle(&self) -> AbortHandle

Returns an abort handle which can be used to remotely terminate a running Command and all its subtask.

This is specifically useful for cancelling subscriptions and long running effects which may get superseded, like timers

Source§

impl<Effect, Event> Command<Effect, Event>
where Effect: Send + 'static, Event: Send + 'static,

Source

pub fn expect_one_effect(&mut self) -> Effect

Assert that the Command contains exactly one effect and zero events, and return the effect

§Panics

Panics if the command does not contain exactly one effect, or contains any events.

Trait Implementations§

Source§

impl<Effect, Event, Task> From<NotificationBuilder<Effect, Event, Task>> for Command<Effect, Event>
where Effect: Send + 'static, Event: Send + 'static, Task: Future<Output = ()> + Send + 'static,

Source§

fn from(value: NotificationBuilder<Effect, Event, Task>) -> Self

Converts to this type from the input type.
Source§

impl<Effect, Event> FromIterator<Command<Effect, Event>> for Command<Effect, Event>
where Effect: Send + Unpin + 'static, Event: Send + Unpin + 'static,

Source§

fn from_iter<I: IntoIterator<Item = Command<Effect, Event>>>(iter: I) -> Self

Creates a value from an iterator. Read more
Source§

impl<Effect, Event> Stream for Command<Effect, Event>
where Effect: Unpin + Send + 'static, Event: Unpin + Send + 'static,

Source§

type Item = CommandOutput<Effect, Event>

Values yielded by the stream.
Source§

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted. Read more
Source§

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream. Read more

Auto Trait Implementations§

§

impl<Effect, Event> Freeze for Command<Effect, Event>

§

impl<Effect, Event> !RefUnwindSafe for Command<Effect, Event>

§

impl<Effect, Event> Send for Command<Effect, Event>
where Effect: Send, Event: Send,

§

impl<Effect, Event> !Sync for Command<Effect, Event>

§

impl<Effect, Event> Unpin for Command<Effect, Event>
where Effect: Unpin, Event: Unpin,

§

impl<Effect, Event> !UnwindSafe for Command<Effect, Event>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> Convert<T> for T

Source§

fn convert(source: T) -> T

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> StreamExt for T
where T: Stream + ?Sized,

Source§

fn next(&mut self) -> Next<'_, Self>
where Self: Unpin,

Creates a future that resolves to the next item in the stream. Read more
Source§

fn into_future(self) -> StreamFuture<Self>
where Self: Sized + Unpin,

Converts this stream into a future of (next_item, tail_of_stream). If the stream terminates, then the next item is None. Read more
Source§

fn map<T, F>(self, f: F) -> Map<Self, F>
where F: FnMut(Self::Item) -> T, Self: Sized,

Maps this stream’s items to a different type, returning a new stream of the resulting type. Read more
Source§

fn enumerate(self) -> Enumerate<Self>
where Self: Sized,

Creates a stream which gives the current iteration count as well as the next value. Read more
Source§

fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>
where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,

Filters the values produced by this stream according to the provided asynchronous predicate. Read more
Source§

fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, Self: Sized,

Filters the values produced by this stream while simultaneously mapping them to a different type according to the provided asynchronous closure. Read more
Source§

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future, Self: Sized,

Computes from this stream’s items new items of a different type using an asynchronous closure. Read more
Source§

fn collect<C>(self) -> Collect<Self, C>
where C: Default + Extend<Self::Item>, Self: Sized,

Transforms a stream into a collection, returning a future representing the result of that computation. Read more
Source§

fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>
where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,

Converts a stream of pairs into a future, which resolves to pair of containers. Read more
Source§

fn concat(self) -> Concat<Self>
where Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,

Concatenate all items of a stream into a single extendable destination, returning a future representing the end result. Read more
Source§

fn count(self) -> Count<Self>
where Self: Sized,

Drives the stream to completion, counting the number of items. Read more
Source§

fn cycle(self) -> Cycle<Self>
where Self: Sized + Clone,

Repeats a stream endlessly. Read more
Source§

fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>
where F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>, Self: Sized,

Execute an accumulating asynchronous computation over a stream, collecting all the values into one final result. Read more
Source§

fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,

Execute predicate over asynchronous stream, and return true if any element in stream satisfied a predicate. Read more
Source§

fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,

Execute predicate over asynchronous stream, and return true if all element in stream satisfied a predicate. Read more
Source§

fn flatten(self) -> Flatten<Self>
where Self::Item: Stream, Self: Sized,

Flattens a stream of streams into just one continuous stream. Read more
Source§

fn flatten_unordered( self, limit: impl Into<Option<usize>>, ) -> FlattenUnorderedWithFlowController<Self, ()>
where Self::Item: Stream + Unpin, Self: Sized,

Flattens a stream of streams into just one continuous stream. Polls inner streams produced by the base stream concurrently. Read more
Source§

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where F: FnMut(Self::Item) -> U, U: Stream, Self: Sized,

Maps a stream like StreamExt::map but flattens nested Streams. Read more
Source§

fn flat_map_unordered<U, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> FlatMapUnordered<Self, U, F>
where U: Stream + Unpin, F: FnMut(Self::Item) -> U, Self: Sized,

Maps a stream like StreamExt::map but flattens nested Streams and polls them concurrently, yielding items in any order, as they made available. Read more
Source§

fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>
where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option<B>>, Self: Sized,

Combinator similar to StreamExt::fold that holds internal state and produces a new stream. Read more
Source§

fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>
where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,

Skip elements on this stream while the provided asynchronous predicate resolves to true. Read more
Source§

fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>
where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,

Take elements from this stream while the provided asynchronous predicate resolves to true. Read more
Source§

fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>
where Fut: Future, Self: Sized,

Take elements from this stream until the provided future resolves. Read more
Source§

fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,

Runs this stream to completion, executing the provided asynchronous closure for each element on the stream. Read more
Source§

fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> ForEachConcurrent<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,

Runs this stream to completion, executing the provided asynchronous closure for each element on the stream concurrently as elements become available. Read more
Source§

fn take(self, n: usize) -> Take<Self>
where Self: Sized,

Creates a new stream of at most n items of the underlying stream. Read more
Source§

fn skip(self, n: usize) -> Skip<Self>
where Self: Sized,

Creates a new stream which skips n items of the underlying stream. Read more
Source§

fn fuse(self) -> Fuse<Self>
where Self: Sized,

Fuse a stream such that poll_next will never again be called once it has finished. This method can be used to turn any Stream into a FusedStream. Read more
Source§

fn by_ref(&mut self) -> &mut Self

Borrows a stream, rather than consuming it. Read more
Source§

fn catch_unwind(self) -> CatchUnwind<Self>
where Self: Sized + UnwindSafe,

Catches unwinding panics while polling the stream. Read more
Source§

fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>
where Self: Sized + Send + 'a,

Wrap the stream in a Box, pinning it. Read more
Source§

fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>
where Self: Sized + 'a,

Wrap the stream in a Box, pinning it. Read more
Source§

fn buffered(self, n: usize) -> Buffered<Self>
where Self::Item: Future, Self: Sized,

An adaptor for creating a buffered list of pending futures. Read more
Source§

fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
where Self::Item: Future, Self: Sized,

An adaptor for creating a buffered list of pending futures (unordered). Read more
Source§

fn zip<St>(self, other: St) -> Zip<Self, St>
where St: Stream, Self: Sized,

An adapter for zipping two streams together. Read more
Source§

fn chain<St>(self, other: St) -> Chain<Self, St>
where St: Stream<Item = Self::Item>, Self: Sized,

Adapter for chaining two streams. Read more
Source§

fn peekable(self) -> Peekable<Self>
where Self: Sized,

Creates a new stream which exposes a peek method. Read more
Source§

fn chunks(self, capacity: usize) -> Chunks<Self>
where Self: Sized,

An adaptor for chunking up items of the stream inside a vector. Read more
Source§

fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
where Self: Sized,

An adaptor for chunking up ready items of the stream inside a vector. Read more
Source§

fn forward<S>(self, sink: S) -> Forward<Self, S>
where S: Sink<Self::Ok, Error = Self::Error>, Self: Sized + TryStream,

A future that completes after the given stream has been fully processed into the sink and the sink has been flushed and closed. Read more
Source§

fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>)
where Self: Sized + Sink<Item>,

Splits this Stream + Sink object into separate Sink and Stream objects. Read more
Source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where F: FnMut(&Self::Item), Self: Sized,

Do something with each item of this stream, afterwards passing it on. Read more
Source§

fn left_stream<B>(self) -> Either<Self, B>
where B: Stream<Item = Self::Item>, Self: Sized,

Wrap this stream in an Either stream, making it the left-hand variant of that Either. Read more
Source§

fn right_stream<B>(self) -> Either<B, Self>
where B: Stream<Item = Self::Item>, Self: Sized,

Wrap this stream in an Either stream, making it the right-hand variant of that Either. Read more
Source§

fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>
where Self: Unpin,

A convenience method for calling Stream::poll_next on Unpin stream types.
Source§

fn select_next_some(&mut self) -> SelectNextSome<'_, Self>
where Self: Unpin + FusedStream,

Returns a Future that resolves when the next item in this stream is ready. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.