Enums and State Machines

package main

import (
	"fmt"
	"strings"
)

// State and Event are enums: a closed set of names instead of free-form strings.
type State int

const (
	Placed State = iota
	Paid
	Shipped
	Delivered
	Cancelled
)

func (s State) String() string {
	return [...]string{"placed", "paid", "shipped", "delivered", "cancelled"}[s]
}

type Event string

const (
	Pay     Event = "pay"
	Ship    Event = "ship"
	Deliver Event = "deliver"
	Cancel  Event = "cancel"
)

// The whole lifecycle in one table: from a state, which events are allowed, and where they lead.
// Anything not listed is an invalid transition.
var transitions = map[State]map[Event]State{
	Placed:  {Pay: Paid, Cancel: Cancelled},
	Paid:    {Ship: Shipped, Cancel: Cancelled},
	Shipped: {Deliver: Delivered},
	// Delivered and Cancelled are final: no way out.
}

type Order struct {
	ID      int
	state   State
	history []State
}

func NewOrder(id int) *Order {
	return &Order{ID: id, state: Placed, history: []State{Placed}}
}

// Apply is the only way to change the state, so an impossible state can't be reached.
func (o *Order) Apply(e Event) error {
	next, ok := transitions[o.state][e]
	if !ok {
		return fmt.Errorf("cannot %s when %s", e, o.state)
	}
	o.state = next
	o.history = append(o.history, next)
	return nil
}

func (o *Order) History() string {
	parts := []string{}
	for _, s := range o.history {
		parts = append(parts, s.String())
	}
	return strings.Join(parts, " > ")
}

func run(o *Order, events ...Event) {
	for _, e := range events {
		from := o.state
		if err := o.Apply(e); err != nil {
			fmt.Printf("%-8s %-9s : %v\n", e, from, err)
		} else {
			fmt.Printf("%-8s %-9s -> %s\n", e, from, o.state)
		}
	}
}

func main() {
	a := NewOrder(1001)
	fmt.Printf("order %d %s\n", a.ID, a.state)
	run(a, Pay, Ship, Cancel, Deliver, Deliver)

	b := NewOrder(1002)
	fmt.Printf("order %d %s\n", b.ID, b.state)
	run(b, Cancel, Pay)

	fmt.Printf("history %d: %s\n", a.ID, a.History())
	fmt.Printf("history %d: %s\n", b.ID, b.History())
}

from enum import Enum


class State(Enum):
    """A closed set of names instead of free-form strings."""
    PLACED = "placed"
    PAID = "paid"
    SHIPPED = "shipped"
    DELIVERED = "delivered"
    CANCELLED = "cancelled"


class Event(Enum):
    PAY = "pay"
    SHIP = "ship"
    DELIVER = "deliver"
    CANCEL = "cancel"


# The whole lifecycle in one table. Anything not listed is an invalid transition.
TRANSITIONS: dict[State, dict[Event, State]] = {
    State.PLACED: {Event.PAY: State.PAID, Event.CANCEL: State.CANCELLED},
    State.PAID: {Event.SHIP: State.SHIPPED, Event.CANCEL: State.CANCELLED},
    State.SHIPPED: {Event.DELIVER: State.DELIVERED},
    # DELIVERED and CANCELLED are final: no way out.
}


class InvalidTransition(Exception):
    pass


class Order:
    def __init__(self, id: int):
        self.id = id
        self._state = State.PLACED
        self._history = [State.PLACED]

    @property
    def state(self) -> State:
        return self._state

    def apply(self, e: Event) -> None:
        """The only way to change the state, so an impossible state can't be reached."""
        nxt = TRANSITIONS.get(self._state, {}).get(e)
        if nxt is None:
            raise InvalidTransition(f"cannot {e.value} when {self._state.value}")
        self._state = nxt
        self._history.append(nxt)

    def history(self) -> str:
        return " > ".join(s.value for s in self._history)


def run(o: Order, *events: Event) -> None:
    for e in events:
        frm = o.state
        try:
            o.apply(e)
            print(f"{e.value:<8} {frm.value:<9} -> {o.state.value}")
        except InvalidTransition as err:
            print(f"{e.value:<8} {frm.value:<9} : {err}")


a = Order(1001)
print(f"order {a.id} {a.state.value}")
run(a, Event.PAY, Event.SHIP, Event.CANCEL, Event.DELIVER, Event.DELIVER)

b = Order(1002)
print(f"order {b.id} {b.state.value}")
run(b, Event.CANCEL, Event.PAY)

print(f"history {a.id}: {a.history()}")
print(f"history {b.id}: {b.history()}")

// String-literal unions are TypeScript's enums: a closed set of names, checked by the compiler.
// (OrderEvent, because the browser already has a global named Event.)
type State = "placed" | "paid" | "shipped" | "delivered" | "cancelled";
type OrderEvent = "pay" | "ship" | "deliver" | "cancel";

// The whole lifecycle in one table. Anything not listed is an invalid transition.
const TRANSITIONS: Partial<Record<State, Partial<Record<OrderEvent, State>>>> = {
  placed: { pay: "paid", cancel: "cancelled" },
  paid: { ship: "shipped", cancel: "cancelled" },
  shipped: { deliver: "delivered" },
  // delivered and cancelled are final: no way out.
};

class Order {
  readonly id: number;
  #state: State = "placed";
  #history: State[] = ["placed"];
  constructor(id: number) {
    this.id = id;
  }
  get state(): State {
    return this.#state;
  }
  // The only way to change the state, so an impossible state can't be reached.
  apply(e: OrderEvent): void {
    const next = TRANSITIONS[this.#state]?.[e];
    if (!next) throw new Error(`cannot ${e} when ${this.#state}`);
    this.#state = next;
    this.#history.push(next);
  }
  history(): string {
    return this.#history.join(" > ");
  }
}

function run(o: Order, ...events: OrderEvent[]): void {
  for (const e of events) {
    const from = o.state;
    try {
      o.apply(e);
      console.log(`${e.padEnd(8)} ${from.padEnd(9)} -> ${o.state}`);
    } catch (err) {
      console.log(`${e.padEnd(8)} ${from.padEnd(9)} : ${(err as Error).message}`);
    }
  }
}

const a = new Order(1001);
console.log(`order ${a.id} ${a.state}`);
run(a, "pay", "ship", "cancel", "deliver", "deliver");

const b = new Order(1002);
console.log(`order ${b.id} ${b.state}`);
run(b, "cancel", "pay");

console.log(`history ${a.id}: ${a.history()}`);
console.log(`history ${b.id}: ${b.history()}`);

use std::fmt;

// Enums: a closed set of states. `match` below must cover every case, or it won't compile.
#[derive(Clone, Copy, PartialEq, Debug)]
enum State { Placed, Paid, Shipped, Delivered, Cancelled }

#[derive(Clone, Copy, Debug)]
enum Event { Pay, Ship, Deliver, Cancel }

impl fmt::Display for State {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.pad(match self {
            State::Placed => "placed", State::Paid => "paid", State::Shipped => "shipped",
            State::Delivered => "delivered", State::Cancelled => "cancelled",
        })
    }
}
impl fmt::Display for Event {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.pad(match self { Event::Pay => "pay", Event::Ship => "ship", Event::Deliver => "deliver", Event::Cancel => "cancel" })
    }
}

// The whole lifecycle in one match. Anything not listed is an invalid transition.
fn transition(s: State, e: Event) -> Option<State> {
    use {Event::*, State::*};
    match (s, e) {
        (Placed, Pay) => Some(Paid),
        (Placed, Cancel) | (Paid, Cancel) => Some(Cancelled),
        (Paid, Ship) => Some(Shipped),
        (Shipped, Deliver) => Some(Delivered),
        _ => None, // Delivered and Cancelled are final: no way out.
    }
}

struct Order { id: u32, state: State, history: Vec<State> }

impl Order {
    fn new(id: u32) -> Order { Order { id, state: State::Placed, history: vec![State::Placed] } }

    // The only way to change the state, so an impossible state can't be reached.
    fn apply(&mut self, e: Event) -> Result<(), String> {
        let next = transition(self.state, e).ok_or(format!("cannot {e} when {}", self.state))?;
        self.state = next;
        self.history.push(next);
        Ok(())
    }

    fn history(&self) -> String {
        self.history.iter().map(|s| s.to_string()).collect::<Vec<_>>().join(" > ")
    }
}

fn run(o: &mut Order, events: &[Event]) {
    for &e in events {
        let from = o.state;
        match o.apply(e) {
            Ok(()) => println!("{e:<8} {from:<9} -> {}", o.state),
            Err(err) => println!("{e:<8} {from:<9} : {err}"),
        }
    }
}

fn main() {
    use Event::*;
    let mut a = Order::new(1001);
    println!("order {} {}", a.id, a.state);
    run(&mut a, &[Pay, Ship, Cancel, Deliver, Deliver]);

    let mut b = Order::new(1002);
    println!("order {} {}", b.id, b.state);
    run(&mut b, &[Cancel, Pay]);

    println!("history {}: {}", a.id, a.history());
    println!("history {}: {}", b.id, b.history());
}

import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    // Enums: a closed set of names instead of free-form strings.
    enum State {
        PLACED, PAID, SHIPPED, DELIVERED, CANCELLED;
        @Override public String toString() { return name().toLowerCase(); }
    }

    enum Event {
        PAY, SHIP, DELIVER, CANCEL;
        @Override public String toString() { return name().toLowerCase(); }
    }

    // The whole lifecycle in one table. Anything not listed is an invalid transition.
    static final Map<State, Map<Event, State>> TRANSITIONS = new EnumMap<>(Map.of(
        State.PLACED, Map.of(Event.PAY, State.PAID, Event.CANCEL, State.CANCELLED),
        State.PAID, Map.of(Event.SHIP, State.SHIPPED, Event.CANCEL, State.CANCELLED),
        State.SHIPPED, Map.of(Event.DELIVER, State.DELIVERED)
        // DELIVERED and CANCELLED are final: no way out.
    ));

    static final class InvalidTransition extends Exception {
        private static final long serialVersionUID = 1L;
        InvalidTransition(String msg) { super(msg); }
    }

    static final class Order {
        final int id;
        private State state = State.PLACED;
        private final List<State> history = new ArrayList<>(List.of(State.PLACED));

        Order(int id) { this.id = id; }
        State state() { return state; }

        // The only way to change the state, so an impossible state can't be reached.
        void apply(Event e) throws InvalidTransition {
            State next = TRANSITIONS.getOrDefault(state, Map.of()).get(e);
            if (next == null) throw new InvalidTransition("cannot " + e + " when " + state);
            state = next;
            history.add(next);
        }

        String history() { return history.stream().map(State::toString).collect(Collectors.joining(" > ")); }
    }

    static void run(Order o, Event... events) {
        for (Event e : events) {
            State from = o.state();
            try {
                o.apply(e);
                System.out.printf("%-8s %-9s -> %s%n", e, from, o.state());
            } catch (InvalidTransition err) {
                System.out.printf("%-8s %-9s : %s%n", e, from, err.getMessage());
            }
        }
    }

    public static void main(String[] args) {
        Order a = new Order(1001);
        System.out.printf("order %d %s%n", a.id, a.state());
        run(a, Event.PAY, Event.SHIP, Event.CANCEL, Event.DELIVER, Event.DELIVER);

        Order b = new Order(1002);
        System.out.printf("order %d %s%n", b.id, b.state());
        run(b, Event.CANCEL, Event.PAY);

        System.out.printf("history %d: %s%n", a.id, a.history());
        System.out.printf("history %d: %s%n", b.id, b.history());
    }
}

#include <cstdio>
#include <map>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

// enum class: a closed set of names, and no silent conversion to int.
enum class State { Placed, Paid, Shipped, Delivered, Cancelled };
enum class Event { Pay, Ship, Deliver, Cancel };

const char* name(State s) {
    switch (s) {
        case State::Placed: return "placed";
        case State::Paid: return "paid";
        case State::Shipped: return "shipped";
        case State::Delivered: return "delivered";
        case State::Cancelled: return "cancelled";
    }
    return "?";
}
const char* name(Event e) {
    switch (e) {
        case Event::Pay: return "pay";
        case Event::Ship: return "ship";
        case Event::Deliver: return "deliver";
        case Event::Cancel: return "cancel";
    }
    return "?";
}

// The whole lifecycle in one table. Anything not listed is an invalid transition.
const std::map<std::pair<State, Event>, State> kTransitions = {
    {{State::Placed, Event::Pay}, State::Paid},
    {{State::Placed, Event::Cancel}, State::Cancelled},
    {{State::Paid, Event::Ship}, State::Shipped},
    {{State::Paid, Event::Cancel}, State::Cancelled},
    {{State::Shipped, Event::Deliver}, State::Delivered},
    // Delivered and Cancelled are final: no way out.
};

class Order {
public:
    explicit Order(int id) : id(id) {}
    const int id;
    State state() const { return state_; }

    // The only way to change the state, so an impossible state can't be reached.
    void apply(Event e) {
        auto it = kTransitions.find({state_, e});
        if (it == kTransitions.end())
            throw std::runtime_error(std::string("cannot ") + name(e) + " when " + name(state_));
        state_ = it->second;
        history_.push_back(state_);
    }

    std::string history() const {
        std::string out;
        for (State s : history_) out += (out.empty() ? "" : " > ") + std::string(name(s));
        return out;
    }

private:
    State state_ = State::Placed;
    std::vector<State> history_{State::Placed};
};

void run(Order& o, std::vector<Event> events) {
    for (Event e : events) {
        State from = o.state();
        try {
            o.apply(e);
            std::printf("%-8s %-9s -> %s\n", name(e), name(from), name(o.state()));
        } catch (const std::exception& err) {
            std::printf("%-8s %-9s : %s\n", name(e), name(from), err.what());
        }
    }
}

int main() {
    Order a(1001);
    std::printf("order %d %s\n", a.id, name(a.state()));
    run(a, {Event::Pay, Event::Ship, Event::Cancel, Event::Deliver, Event::Deliver});

    Order b(1002);
    std::printf("order %d %s\n", b.id, name(b.state()));
    run(b, {Event::Cancel, Event::Pay});

    std::printf("history %d: %s\n", a.id, a.history().c_str());
    std::printf("history %d: %s\n", b.id, b.history().c_str());
}