Enum Body

pub enum Body<W, A> {
    Application(A),
    Error(Error),
    Init(Init),
    Workload(W),
}

Variants

Application(A)

An application defined node-to-node message

From the Maelstrom message documentation

Messages exchanged between your server nodes may have any body structure you like; you are not limited to request-response, and may invent any message semantics you choose. If some of your messages do use the body format described above, Maelstrom can help generate useful visualizations and statistics for those messages.

Error(Error)

Init(Init)

Workload(W)

Trait Implementations

impl<W: Debug, A: Debug> Debug for Body<W, A>

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

Formats the value using the given formatter.

impl<'de, W, A> Deserialize<'de> for Body<W, A>

where W: Deserialize<'de>, A: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<W: PartialEq, A: PartialEq> PartialEq for Body<W, A>

fn eq(&self, other: &Body<W, A>) -> 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<W, A> Serialize for Body<W, A>

where W: Serialize, A: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<W: Eq, A: Eq> Eq for Body<W, A>

impl<W, A> StructuralPartialEq for Body<W, A>