Enum MaybeUndefined 

pub enum MaybeUndefined<T> {
    Undefined,
    Null,
    Value(T),
}

A three-state field value: undefined (omitted), null (explicit clear), or a concrete value.

See the module documentation for the rationale and wire-format mapping.

Struct-context contract

The Undefined / Null distinction is preserved on the wire only when this value sits in a struct field carrying #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")] — which is what codegen emits for every nullable input field. In any other context (serde_json::to_value(MaybeUndefined::<T>::Undefined), a bare value inside a Vec<MaybeUndefined<T>>, etc.) Undefined cannot be “omitted” — there’s no containing struct to omit it from — and serializes as JSON null, collapsing the distinction. Use this type only as a struct field paired with the skip predicate above.

Derive bounds

The Eq and Hash impls are conditional on T: Eq + Hash. Types containing non-Eq scalars (notably f64) therefore can’t derive those traits transitively — this is expected and matches Option<T>.

Variants

Undefined

Field is absent from the serialized output.

Null

Field is serialized as JSON null (clears the value on the server).

Value(T)

Field is serialized as the wrapped value.

Implementations

impl<T> MaybeUndefined<T>

pub fn is_undefined(&self) -> bool

Returns true if the value is MaybeUndefined::Undefined.

Codegen uses this as the skip_serializing_if predicate so Undefined fields are omitted from the serialized output entirely.

Trait Implementations

impl<T: Clone> Clone for MaybeUndefined<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MaybeUndefined<T>

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

Formats the value using the given formatter.

impl<T> Default for MaybeUndefined<T>

fn default() -> Self

Returns the “default value” for a type.

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

Maps the three JSON inputs a struct field can present as follows:

Input	Result
field absent from JSON	Undefined (via #[serde(default)])
field present with null	Null
field present with a value v	Value(v)

Absent-field handling is driven by #[serde(default)] on the struct field, not by this impl — serde only calls deserialize when the key is present. Codegen emits that attribute on every nullable input field, which is what preserves the three-state distinction on round-trip.

Note the intentional asymmetry with From<Option<T>>: None → Undefined during construction (a missing CLI flag shouldn’t touch the server), but JSON null → Null during deserialization (the server did send null).

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

Deserialize this value from the given Serde deserializer.

impl<T> From<Option<T>> for MaybeUndefined<T>

Lifts an Option<T> into the three-state world, collapsing None to Undefined.

This is the right default for constructing input values: a CLI flag that wasn’t passed (Option::None) means “leave the field unchanged”, so it maps to Undefined. If you instead want None to clear the field on the server, use MaybeUndefined::Null explicitly.

Note the intentional asymmetry with Deserialize: when round-tripping through JSON, an absent field deserializes to Undefined (via the #[serde(default)] on the field), while an explicit JSON null deserializes to Null. That matches GraphQL’s wire semantics. Option<T> doesn’t carry the “absent” vs “null” distinction, so From<Option<T>> can’t preserve it either.

fn from(o: Option<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for MaybeUndefined<T>

fn from(v: T) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for MaybeUndefined<T>

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<T: PartialEq> PartialEq for MaybeUndefined<T>

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

impl<T> StructuralPartialEq for MaybeUndefined<T>