Struct Commented 

pub struct Commented<T>(pub T, pub String);

Attach an inline YAML comment to a value when serializing.

This wrapper lets you annotate a scalar with an inline YAML comment that is emitted after the value when using block style. The typical form is: value # comment.

Behavior

• Block style (default): the comment appears after the scalar on the same line.
• Flow style (inside [ ... ] or { ... }): comments are suppressed to keep the flow representation compact and unambiguous.
• Complex values (sequences/maps/structs): the comment is ignored; only the inner value is serialized to preserve indentation and layout.
• Newlines in comments are sanitized to spaces so the comment remains on a single line (e.g., “a\nb” becomes “a b”).
• Deserialization of Commented<T> ignores comments: it behaves like T and produces an empty comment string.

Examples

Basic scalar with a comment in block style:

use serde::Serialize;

// Re-exported from the crate root
use serde_saphyr::Commented;

let out = serde_saphyr::to_string(&Commented(42, "answer".to_string())).unwrap();
assert_eq!(out, "42 # answer\n");

As a mapping value, still inline:

use serde::Serialize;
use serde_saphyr::Commented;

#[derive(Serialize)]
struct S { n: Commented<i32> }

let s = S { n: Commented(5, "send five starships first".into()) };
let out = serde_saphyr::to_string(&s).unwrap();
assert_eq!(out, "n: 5 # send five starships first\n");

Important: Comments are suppressed in flow contexts (no # appears), and ignored for complex inner values. Value with Commented wrapper will be deserializaed correctly as well, but deserialization of comment is currently not supported.

Tuple Fields

0: T

1: String

Trait Implementations

impl<T: Clone> Clone for Commented<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Commented<T>

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

Formats the value using the given formatter.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Commented<T>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for Commented<T>

fn eq(&self, other: &Commented<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: Serialize> Serialize for Commented<T>

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Commented<T>

impl<T> StructuralPartialEq for Commented<T>