Enum Handled

pub enum Handled<T> {
    Matched(T),
    Unmatched,
}

The reaction of an event handler to a particular event.

Handled describes whether or not a handler has matched a particular event. When matched, a handler may include an arbitrary output. When unmatched, there is no further output. Whether or not a handler has matched an event can affect the execution of a composite handler and the test harness.

Note that matching an event has no precise definition: handlers may react arbitrarily to events. In practice, there is little ambiguity, but handlers and adapters can match in particular ways to enable certain handler behaviors. See the until_first_match adapter for an example.

Variants

Matched(T)

An event handler has matched and handled an event.

Unmatched

An event handler has not matched nor handled an event.

Implementations

impl<T> Handled<T>

pub fn map<U, F>(self, f: F) -> Handled<U>

where F: FnOnce(T) -> U,

pub fn and_then<U, F>(self, f: F) -> Handled<U>

where F: FnOnce(T) -> Handled<U>,

pub fn and<U>(self, right: Handled<U>) -> Handled<U>

pub fn try_and_then<U, F>(self, f: F) -> Handled<U>

where T: Try, F: FnOnce(T::Output) -> Handled<U>,

pub fn or_else<F>(self, f: F) -> Self

where F: FnOnce() -> Self,

pub fn or(self, right: Self) -> Self

pub fn try_or_else<F>(self, f: F) -> Self

where T: Try, F: FnOnce() -> Self,

pub fn flatten(self) -> Handled<T::Output>

where T: Try,

pub fn matched(self) -> Option<T>

pub fn is_matched(&self) -> bool

pub fn is_unmatched(&self) -> bool

Trait Implementations

impl<T: Clone> Clone for Handled<T>

fn clone(&self) -> Handled<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Handled<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> From<T> for Handled<T>

fn from(matched: T) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Handled<T>

fn eq(&self, other: &Handled<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Try for Handled<T>

type Output = T

type Residual = Handled<Infallible>

fn from_output(output: Self::Output) -> Self

fn from_residual(_: Self::Residual) -> Self

fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

fn unwrap(self) -> Self::Output

where Self: Sized,

fn expect(self, message: impl Display) -> Self::Output

where Self: Sized,

impl<T: Copy> Copy for Handled<T>

impl<T: Eq> Eq for Handled<T>

impl<T> StructuralPartialEq for Handled<T>