Struct Proposal 

pub struct Proposal<State> { /* private fields */ }

A proposal in a specific lifecycle state.

State transitions:

• Proposal<Draft> -> Proposal<Validated> via PromotionGate::validate()
• Proposal<Validated> -> Fact via PromotionGate::promote()

Example

use converge_core::types::{
    Proposal, Draft, ProposalId, ProposedContent, ProposedContentKind,
    ObservationProvenance, ObservationId, ContentHash, CaptureContext,
};

// Create a draft proposal (public)
let draft = Proposal::<Draft>::new(
    ProposalId::new("proposal-001"),
    ProposedContent::new(ProposedContentKind::Claim, "The market is growing"),
    ObservationProvenance::new(
        ObservationId::new("obs-001"),
        ContentHash::zero(),
        CaptureContext::default(),
    ),
);

assert_eq!(draft.id().as_str(), "proposal-001");

Implementations

impl Proposal<Draft>

pub fn new( id: ProposalId, content: ProposedContent, provenance: ObservationProvenance, ) -> Proposal<Draft>

Public constructor for draft proposals.

Anyone can create a draft proposal. It must be validated by a PromotionGate before it can become a Fact.

impl<State> Proposal<State>

pub fn id(&self) -> &ProposalId

Get the proposal ID.

pub fn content(&self) -> &ProposedContent

Get the proposed content.

pub fn provenance(&self) -> &ObservationProvenance

Get the observation provenance.

Trait Implementations

impl<State> Clone for Proposal<State>

where State: Clone,

fn clone(&self) -> Proposal<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State> Debug for Proposal<State>

where State: Debug,

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Proposal<Draft>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> Serialize for Proposal<S>

fn serialize<Ser>( &self, serializer: Ser, ) -> Result<<Ser as Serializer>::Ok, <Ser as Serializer>::Error>

where Ser: Serializer,

Serialize this value into the given Serde serializer.