mindset 0.1.1

A pure functional state machine library built on Stillwater's Effect system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Document Approval Workflow
//!
//! This example demonstrates a multi-stage approval workflow with guards and actions.
//!
//! Key concepts:
//! - Multi-stage linear workflow (Draft -> Review -> Approved -> Published)
//! - Guards control transitions (validation rules)
//! - Actions perform side effects (audit logging)
//! - Final state (Published is terminal)
//!
//! Run with: cargo run --example document_workflow

use mindset::builder::{StateMachineBuilder, TransitionBuilder};
use mindset::state_enum;

state_enum! {
    enum DocState {
        Draft,
        Review,
        Approved,
        Published,
    }
    final: [Published]
}

// Document entity
struct Document {
    id: u64,
    content: String,
    word_count: usize,
}

// Environment trait for audit logging
trait AuditLog {
    fn log_transition(&mut self, doc_id: u64, from: DocState, to: DocState);
}

// Pure guards - validation logic
fn can_submit_for_review(doc: &Document) -> bool {
    !doc.content.is_empty() && doc.word_count >= 100
}

fn can_approve(doc: &Document) -> bool {
    doc.word_count <= 5000
}

// Effectful actions
fn submit_for_review<Env>(doc: &Document, env: &mut Env)
where
    Env: AuditLog,
{
    env.log_transition(doc.id, DocState::Draft, DocState::Review);
}

fn approve_document<Env>(doc: &Document, env: &mut Env)
where
    Env: AuditLog,
{
    env.log_transition(doc.id, DocState::Review, DocState::Approved);
}

fn publish_document<Env>(doc: &Document, env: &mut Env)
where
    Env: AuditLog,
{
    env.log_transition(doc.id, DocState::Approved, DocState::Published);
}

// Simple audit log implementation
struct SimpleAuditLog;

impl AuditLog for SimpleAuditLog {
    fn log_transition(&mut self, doc_id: u64, from: DocState, to: DocState) {
        println!(
            "  [Audit] Document {} transitioned from {:?} to {:?}",
            doc_id, from, to
        );
    }
}

fn main() {
    println!("=== Document Approval Workflow ===\n");

    // Create state machine
    let _machine = StateMachineBuilder::<DocState, ()>::new()
        .initial(DocState::Draft)
        .add_transition(
            TransitionBuilder::new()
                .from(DocState::Draft)
                .to(DocState::Review)
                .succeeds()
                .build()
                .unwrap(),
        )
        .add_transition(
            TransitionBuilder::new()
                .from(DocState::Review)
                .to(DocState::Approved)
                .succeeds()
                .build()
                .unwrap(),
        )
        .add_transition(
            TransitionBuilder::new()
                .from(DocState::Approved)
                .to(DocState::Published)
                .succeeds()
                .build()
                .unwrap(),
        )
        .build()
        .unwrap();

    println!("Created document workflow state machine");
    println!("States: Draft -> Review -> Approved -> Published\n");

    // Create document and audit log
    let doc = Document {
        id: 123,
        content: "Lorem ipsum dolor sit amet...".to_string(),
        word_count: 250,
    };
    let mut audit = SimpleAuditLog;

    // Simulate workflow
    println!("Processing document {}:", doc.id);
    println!("  Word count: {}", doc.word_count);
    println!();

    if can_submit_for_review(&doc) {
        println!("Step 1: Submit for Review");
        submit_for_review(&doc, &mut audit);
        println!("  ✓ Document meets minimum requirements (100+ words)\n");

        if can_approve(&doc) {
            println!("Step 2: Approve");
            approve_document(&doc, &mut audit);
            println!("  ✓ Document within maximum length (5000 words)\n");

            println!("Step 3: Publish");
            publish_document(&doc, &mut audit);
            println!("  ✓ Document published successfully\n");
        }
    }

    println!("Key Takeaways:");
    println!("- Linear workflow with clear progression");
    println!("- Guards enforce business rules (word count)");
    println!("- Actions perform side effects (audit logging)");
    println!("- Final state (Published) is terminal");

    println!("\n=== Example Complete ===");
}