Struct Null 

pub struct Null<AnnotatedT> {
    pub annotated: AnnotatedT,
}

Normal null variant.

Annotations, if present, are ignored for the purposes of comparison and hashing.

Fields

annotated: AnnotatedT

Annotated.

Trait Implementations

impl<AnnotatedT> Annotated for Null<AnnotatedT>

where AnnotatedT: Annotated,

fn can_have_annotations() -> bool

Whether we can have Annotations.

fn annotations(&self) -> Option<&Annotations>

The annotations.

fn annotations_mut(&mut self) -> Option<&mut Annotations>

The annotations as mutable.

fn has_annotations(&self) -> bool

Whether we have Annotations.

fn maybe_annotations(&self) -> MaybeAnnotations<Self>

Create a MaybeAnnotations with our Annotations.

fn with_annotations(self, annotations: Annotations) -> Self

Set annotations.

fn with_annotations_option(self, annotations: Option<Annotations>) -> Self

Set annotations.

fn with_annotations_from<AnnotatedT>(self, source: &AnnotatedT) -> Self

where AnnotatedT: Annotated,

Clone Annotations from another Annotated.

fn with_annotations_from_field<AnnotatedFieldsT>( self, source: &AnnotatedFieldsT, name: &str, ) -> Self

where AnnotatedFieldsT: AnnotatedStruct,

Clone Annotations from another AnnotatedStruct.

fn with_source(self, source: &Option<ByteString>) -> Self

Set source.

fn with_path(self, path: Option<PathRepresentation>) -> Self

Set path.

fn with_path_list_index(self, index: usize) -> Self

Push list index to path.

fn with_path_map_key(self, key: ByteString) -> Self

Push map key to path.

fn with_span(self, span: Option<Span>) -> Self

Set span.

fn with_label(self, label: Option<Label>) -> Self

Set label.

impl<AnnotatedT: Clone> Clone for Null<AnnotatedT>

fn clone(&self) -> Null<AnnotatedT>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<AnnotatedT: Debug> Debug for Null<AnnotatedT>

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

Formats the value using the given formatter.

impl<AnnotatedT> Default for Null<AnnotatedT>

where AnnotatedT: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<AnnotatedT> Depict for Null<AnnotatedT>

fn depict<WriteT>( &self, writer: &mut WriteT, context: &DepictionContext<'_>, ) -> Result<()>

where WriteT: Write,

Write a depiction suitable for terminals.

fn write_depiction<WriteT>( &self, writer: &mut WriteT, context: &DepictionContext<'_>, ) -> Result<(), Error>

where WriteT: Write,

Write the depiction with a final newline.

fn write_default_depiction<WriteT>( &self, writer: &mut WriteT, ) -> Result<(), Error>

where WriteT: Write,

Write the depiction with a final newline.

fn write_plain_depiction<WriteT>( &self, writer: &mut WriteT, ) -> Result<(), Error>

where WriteT: Write,

Write the depiction with a final newline.

fn print_depiction(&self, context: &DepictionContext<'_>)

Print the depiction to anstream::stdout with a final newline.

fn print_default_depiction(&self)

Print the depiction to anstream::stdout with a final newline.

fn print_plain_depiction(&self)

Print the depiction to anstream::stdout with a final newline.

fn eprint_depiction(&self, context: &DepictionContext<'_>)

Print the depiction to anstream::stderr with a final newline.

fn eprint_default_depiction(&self)

Print the depiction to anstream::stderr with a final newline.

fn eprint_plain_depiction(&self)

Print the depiction to anstream::stderr with a final newline.

fn to_depiction(&self, context: &DepictionContext<'_>) -> Result<String, Error>

Capture depict into a String.

fn to_default_depiction(&self) -> Result<String, Error>

Capture depict into a String.

fn to_plain_depiction(&self) -> Result<String, Error>

Capture depict into a String.

impl<AnnotatedT> Display for Null<AnnotatedT>

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

Formats the value using the given formatter.

impl<AnnotatedT> From<()> for Null<AnnotatedT>

where AnnotatedT: Default,

fn from(_: ()) -> Self

Converts to this type from the input type.

impl<AnnotatedT> From<Null<AnnotatedT>> for ()

fn from(_: Null<AnnotatedT>) -> Self

Converts to this type from the input type.

impl<AnnotatedT> From<Null<AnnotatedT>> for Variant<AnnotatedT>

fn from(normal: Null<AnnotatedT>) -> Self

Converts to this type from the input type.

impl<AnnotatedT> Hash for Null<AnnotatedT>

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

where HasherT: Hasher,

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<AnnotatedT, NewAnnotatedT> IntoAnnotated<Null<NewAnnotatedT>> for Null<AnnotatedT>

where AnnotatedT: Annotated, NewAnnotatedT: Annotated + Default,

fn into_annotated(self) -> Null<NewAnnotatedT>

Into different Annotated implementation.

impl<AnnotatedT> Ord for Null<AnnotatedT>

fn cmp(&self, _other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<AnnotatedT> PartialEq for Null<AnnotatedT>

fn eq(&self, _other: &Self) -> 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<AnnotatedT> PartialOrd for Null<AnnotatedT>

fn partial_cmp(&self, _other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<AnnotatedT> RemoveAnnotations<Null<WithoutAnnotations>> for Null<AnnotatedT>

fn remove_annotations(self) -> Null<WithoutAnnotations>

Removes all Annotations recursively.

impl<AnnotatedT> Serialize for Null<AnnotatedT>

Available on crate feature serde only.

fn serialize<SerializerT>( &self, serializer: SerializerT, ) -> Result<SerializerT::Ok, SerializerT::Error>

where SerializerT: Serializer,

Serialize this value into the given Serde serializer.

impl<AnnotatedT> Eq for Null<AnnotatedT>