Enum EventKind 

pub enum EventKind {
    Started {
        request: Ref,
    },
    Claim {
        claim: Ref,
    },
    Diagnostic(Diagnostic),
    Trace(Ref),
    Chunk {
        payload: Ref,
    },
    EffectRequested {
        effect: Ref,
    },
    EffectResolved {
        effect: Ref,
        result: Ref,
    },
    Capture {
        effect: Ref,
    },
    Card {
        subject: Ref,
        card: Ref,
    },
    Final(Ref),
    Failed(Ref),
    Done,
}

The payload variants an Event can carry.

Variants

Started

A run started from the given request.

Fields

request: Ref

Reference to the originating request.

Claim

A claim was asserted.

Fields

claim: Ref

Reference to the asserted claim.

Diagnostic(Diagnostic)

A diagnostic was emitted.

Trace(Ref)

A trace marker was emitted.

Chunk

A streamed chunk of output.

Fields

payload: Ref

Reference to the chunk payload.

EffectRequested

An effect was requested.

Fields

effect: Ref

Reference to the requested effect.

EffectResolved

An effect was resolved with a result.

Fields

effect: Ref

Reference to the resolved effect.

result: Ref

Reference to the effect result.

Capture

A continuation capture occurred at an effect.

Fields

effect: Ref

Reference to the captured effect.

Card

A card was published for a subject.

Fields

subject: Ref

Reference to the card’s subject.

card: Ref

Reference to the card.

Final(Ref)

The run produced its final value.

Failed(Ref)

The run failed with an error.

Done

The run finished.

Trait Implementations

impl Clone for EventKind

fn clone(&self) -> EventKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventKind

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

Formats the value using the given formatter.

impl Eq for EventKind

impl PartialEq for EventKind

fn eq(&self, other: &EventKind) -> 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 StructuralPartialEq for EventKind