Struct CaveatDeferred 

pub struct CaveatDeferred<T, K: Kind> { /* private fields */ }

A value that may have associated warning Kinds.

This caveat is considered deferred as the warning kinds still need to be associated with a json::Element to become Warnings.

Even though the value has been created there may be certain caveats you should be aware of before using it.

NOTE: The deferred types are used to avoid passing json::Element references to functions just to create Warnings.

Implementations

impl<T, K> CaveatDeferred<T, K>

where K: Kind,

pub fn into_parts(self) -> (T, SetDeferred<K>)

Return the value and any warning Kinds stored in the CaveatDeferred.

pub fn ignore_warnings(self) -> T

Return the value and drop any warnings contained within.

pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> CaveatDeferred<U, K>

Map the value to another target type while retaining the warnings about the source type.

Trait Implementations

impl<T: Debug, K: Debug + Kind> Debug for CaveatDeferred<T, K>

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

Formats the value using the given formatter.

impl<T, K> Deref for CaveatDeferred<T, K>

where K: Kind,

A deferred Caveat is simply a value with associated warning Kinds that still need to be associated with a json::Element to become Warnings.

Providing an impl Deref makes sense for given that it’s an annotated value.

The same advice applies to both deref traits. In general, deref traits should be implemented if:

1. a value of the type transparently behaves like a value of the target type;
2. the implementation of the deref function is cheap; and
3. users of the type will not be surprised by any deref coercion behavior.

See: https://doc.rust-lang.org/std/ops/trait.Deref.html#when-to-implement-deref-or-derefmut

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.