Struct Traced 

pub struct Traced<T>
where
    T: Try,
{ /* private fields */ }

The wrapper around a Try-type with associated tracing event. You will usually not interact directly with this type but rather with the trait Trace.

Implementations

impl<T, E> Traced<Result<T, E>>

pub fn err(self) -> Option<E>

Converts from TracedResult<T, E> to Option<E>, emitting any tracing entry in the process.

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

Converts from TracedResult<T, E> to Option<T>, emitting any tracing entry in the process.

Trait Implementations

impl<T, O> Extract<O> for Traced<T>

where T: Try<Output = O>,

Calling any of the extraction functions will emit the enclosed tracing entries related to the relevant variant.

fn output(self) -> Option<T>

Extracts the contained value v returning Some(v), or None in the case of a Residual

fn unwrap(self) -> T

where Self::Residual: Debug,

Return the contained value or panic with a generic message.

fn expect(self, msg: &str) -> T

where Self::Residual: Debug,

Return the contained value or panic with a custom message.

fn unwrap_or(self, default: T) -> T

Return the contained value or the given default.

fn unwrap_or_default(self) -> T

where T: Default,

Return the contained value or a default. Requires T to implement Default

fn unwrap_or_else<F>(self, f: F) -> T

where F: FnOnce() -> T,

Return the contained value or a value computed from a closure.

impl<T: Try> FromResidual for Traced<T>

Note

• The Traced<T> returned from try { Traced<T>? } will have no attached tracing events, as all will be emitted by the ? inside the try block
• FromResidual is primarily implemented as a formality, normal usage will likely be in the form try bikeshed T { Traced<T>? }

fn from_residual(residual: <Self as Try>::Residual) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from a compatible Residual type.

impl<T, O> Transform<O> for Traced<T>

where T: Try<Output = O>,

Calling any of the transformation functions will emit the enclosed tracing entries related to the relevant variant.

fn flatten(self) -> T

where T: FromResidual<Self::Residual>,

Removes one level of nesting, converting Foo<Foo<U>> to Foo<U> or from Foo<Bar<U>> to Bar<U> if suitable residual inter-conversion is implemented.

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

where F: FnOnce(&T),

Calls a function with a reference to the contained value in the output case. Returns the original Self

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

where F: FnOnce(T) -> U, X: Try<Output = U> + FromResidual<Self::Residual>, Self::Residual: Residual<U, TryType = X>,

Applies a function to the contained value (in the ouput case) converting T -> U, leaving residual cases untouched, then returns the canonical TryType for Self with Output U.

fn map_or<U, F>(self, default: U, f: F) -> U

where F: FnOnce(T) -> U,

Applies a function to the contained value (in the output case) converting T -> U, or returns the given default value.

fn map_or_else<U, D, F>(self, default: D, f: F) -> U

where D: FnOnce() -> U, F: FnOnce(T) -> U,

Applies a function to the contained value (in the output case) converting T -> U, or returns the result of default().

fn map_residual<F, X, G>(self, f: F) -> X

where F: FnOnce(Self::Residual) -> G, G: Residual<T, TryType = X>, X: Try<Output = T> + FromResidual<G>,

Applies a function to the residual, leaving output values untouched, then returns the canonical TryType for the residual returned by the function (and Output T).

fn transpose<X>(self) -> X

where T: Try, X: Try + FromResidual<<T as Try>::Residual>, <X as Try>::Output: Try<Output = <T as Try>::Output> + FromResidual<Self::Residual>, <T as Try>::Residual: Residual<<X as Try>::Output, TryType = X>, Self::Residual: Residual<<T as Try>::Output, TryType = <X as Try>::Output>,

Converts from a Foo<Bar<U>> to a Bar<Foo<U>> where both Foo & Bar are Try.

fn zip<X, Y>(self, other: Y) -> X

where Y: Try, X: Try<Output = (T, <Y as Try>::Output)> + FromResidual<Self::Residual> + FromResidual<<Y as Try>::Residual>, Self::Residual: Residual<<X as Try>::Output, TryType = X>,

foo.zip(bar) combines a Foo<T> with a Bar<U> into a Foo<(T,U)> where residual interconversion is available from Bar->Foo. Returns the canonical TryType based upon Foo. Returns a residual if either Foo or Bar are residuals.

fn zip_with<X, Y, F, G>(self, other: Y, f: F) -> X

where Y: Try, F: FnOnce(T, <Y as Try>::Output) -> G, X: Try<Output = G> + FromResidual<Self::Residual> + FromResidual<<Y as Try>::Residual>, Self::Residual: Residual<G, TryType = X>,

foo.zip_with(bar, do_stuff) applies do_stuff(foo?, bar?) to the combined values inside Foo<T> & Bar<U> where residual interconversion is available from Bar->Foo. Returns the canonical TryType based upon Foo.

fn and<Y>(self, other: Y) -> Y

where Y: Try<Output = T> + FromResidual<Self::Residual>,

foo.and(bar) returns bar if foo is the output case, otherwise returns foo.

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

where Y: Try<Output = U> + FromResidual<Self::Residual>, F: FnOnce(T) -> Y,

foo.and_then(bar) calls bar() if foo is the output case, otherwise returns foo.

fn or<Y>(self, other: Y) -> Y

where Y: Try<Output = T>,

foo.or(bar) will return a Bar<T> wrapping the contents of foo if foo is the output case or bar if foo is a residual.

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

where Y: Try<Output = T>, F: FnOnce(Self::Residual) -> Y,

foo.or_else(bar) where bar is a function returning a Bar<T> will return a Bar<T> wrapping the contents of foo if foo is the output case or call bar(foo) if foo is a residual.

impl<T: Try> Try for Traced<T>

Note

• Any attached events are emitted when branch is called and all wrappings are removed, leaving either the Output or Resdiual of the wrapped Try-type. For example: using ? on a Traced<Traced<Option<T>>> will result in either a T or None.
• Traced<T> does not implement its own Output or Residual types but immediately unwraps to the Output / Residual of the wrapped Try-type.

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

🔬This is a nightly-only experimental API. (try_trait_v2)

Used in ? to decide whether the operator should produce a value (because this returned ControlFlow::Continue) or propagate a value back to the caller (because this returned ControlFlow::Break).

Note

Any attached events are emitted when branch is called and all wrappings are removed, leaving either the Output or Resdiual of the wrapped Try-type. For example: using ? on a Traced<Traced<Option<T>>> will result in either a T or None.

type Output = <T as Try>::Output

🔬This is a nightly-only experimental API. (try_trait_v2)

The type of the value produced by ? when not short-circuiting.

type Residual = <T as Try>::Residual

🔬This is a nightly-only experimental API. (try_trait_v2)

The type of the value passed to FromResidual::from_residual as part of ? when short-circuiting.

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

🔬This is a nightly-only experimental API. (try_trait_v2)

Constructs the type from its Output type.