Struct FailedStrategy 

pub struct FailedStrategy<'a, T, S: ?Sized, V> {
    pub strategy: &'a S,
    pub cause: V,
    /* private fields */
}

Error indicating that a strategy failed at a particular position.

Fields

strategy: &'a S

Strategy.

cause: V

Verification error.

Implementations

impl<'a, T, S: Strategy, V> FailedStrategy<'a, T, S, V>

pub fn erased_strategy(self) -> FailedStrategy<'a, T, dyn StrategyObj + 'a, V>

Erase the strategy type, so the error can be more general.

impl<'a, T, S: ?Sized, V> FailedStrategy<'a, T, S, V>

pub fn empty(strategy: &'a S, cause: V) -> FailedStrategy<'a, T, S, V>

Creates an error for an empty result.

pub fn map<U, F: FnOnce(V) -> U>(self, f: F) -> FailedStrategy<'a, T, S, U>

Applies a function to the cause.

pub fn index(&self) -> Option<usize>

Get the unsigned index of the error.

pub fn valid_forward(&self) -> RangeTo<usize>

Get the valid values in the forward direction.

pub fn valid_backward(&self) -> RangeFrom<usize>

Get the valid values in the backward direction.

Trait Implementations

impl<T, S: ?Sized, V: Clone> Clone for FailedStrategy<'_, T, S, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S: ?Sized, V: Copy> Copy for FailedStrategy<'_, T, S, V>

impl<T: Debug, S: ?Sized + Debug, V: Debug> Debug for FailedStrategy<'_, T, S, V>

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

Formats the value using the given formatter.

impl<T: Debug, S: ?Sized + Display, V: Display> Display for FailedStrategy<'_, T, S, V>

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

Formats the value using the given formatter.

impl<T: Eq, S: ?Sized + Eq, V: Eq> Eq for FailedStrategy<'_, T, S, V>

impl<'a, A: ?Sized + Accum, S: ?Sized, V> From<FailedStrategy<'a, <A as Accum>::Item, S, V>> for AccumVerifyError<'a, A, S, V>

fn from(err: FailedStrategy<'a, A::Item, S, V>) -> AccumVerifyError<'a, A, S, V>

Converts to this type from the input type.

impl<'a, T, S: ?Sized, V> From<Infallible> for FailedStrategy<'a, T, S, V>

fn from(err: Infallible) -> FailedStrategy<'a, T, S, V>

Converts to this type from the input type.

impl<T: Hash, S: ?Sized + Hash, V: Hash> Hash for FailedStrategy<'_, T, S, V>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T: PartialEq, S: ?Sized + PartialEq, V: PartialEq> PartialEq for FailedStrategy<'a, T, S, V>

fn eq(&self, rhs: &FailedStrategy<'a, T, S, V>) -> 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.