MVU 패턴

using System;
using System.Collections.Generic;
using System.Linq;

var runtime = new Runtime(new Model(0));
Console.WriteLine($"{"start",-9} -> {runtime.Screen}");
// 버튼 클릭 대신 미리 정한 메시지 목록을 차례로 보낸다.
Msg[] clicks = [new Increment(), new Increment(), new Decrement(), new Reset()];
foreach (Msg msg in clicks)
{
    runtime.Dispatch(msg);
    Console.WriteLine($"{msg.GetType().Name,-9} -> {runtime.Screen}");
}

// 모델: 화면에 필요한 상태 전부를 담는 불변 값이다.
sealed record Model(int Count);

// 메시지: 화면에서 일어날 수 있는 일의 목록이다.
abstract record Msg;
sealed record Increment : Msg;
sealed record Decrement : Msg;
sealed record Reset : Msg;

static class Counter
{
    // 업데이트: 현재 모델과 메시지만으로 다음 모델을 계산한다.
    public static Model Update(Model model, Msg msg) => msg switch
    {
        Increment => model with { Count = model.Count + 1 },
        Decrement => model with { Count = model.Count - 1 },
        Reset => model with { Count = 0 },
        // C#에는 닫힌 합 타입이 없어서 모든 하위 타입을 다뤄도 CS8509 경고가 나므로 마지막 갈래를 둔다.
        _ => throw new ArgumentOutOfRangeException(nameof(msg), msg, "unknown message"),
    };

    // 뷰: 모델만 보고 화면을 만든다.
    public static string View(Model model) => $"[ - ] {model.Count} [ + ]";
}

// 런타임: 모델을 한 곳에 보관하고, 메시지마다 Update와 View를 차례로 부른다.
sealed class Runtime(Model initial)
{
    private Model model = initial;
    public string Screen { get; private set; } = Counter.View(initial);

    public void Dispatch(Msg msg)
    {
        model = Counter.Update(model, msg);
        Screen = Counter.View(model);
    }
}

start     -> [ - ] 0 [ + ]
Increment -> [ - ] 1 [ + ]
Increment -> [ - ] 2 [ + ]
Decrement -> [ - ] 1 [ + ]
Reset     -> [ - ] 0 [ + ]

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;

// 가짜 저장소: 첫 저장은 실패하고 두 번째 저장은 성공한다.
var store = new FakeStore([false, true]);
var runtime = new Runtime(Todo.Init, store.Run);

runtime.Dispatch(new Add("buy milk"));
runtime.Dispatch(new Add("   "));
runtime.Dispatch(new Add("write report"));
runtime.Dispatch(new Toggle(1));
runtime.Dispatch(new Toggle(42));
runtime.Dispatch(new Save());
runtime.Dispatch(new Save());
runtime.RunEffects();
runtime.Dispatch(new Save());
runtime.RunEffects();
runtime.Dispatch(new Undo());

Console.WriteLine($"log: {runtime.Log.Count} messages, store calls: {store.Calls}");
// 기록한 메시지를 처음 모델부터 다시 접는다. 명령은 실행하지 않는다.
Model replayed = runtime.Log.Aggregate(Todo.Init, (model, msg) => Todo.Update(model, msg).Model);
Console.WriteLine($"replay: {Todo.View(replayed)}");
// 레코드의 리스트 필드는 참조로 비교되므로, 항목은 SequenceEqual로 비교하고 나머지 필드는 Items를 맞춘 뒤 레코드 비교로 확인한다.
bool same = replayed.Items.SequenceEqual(runtime.Model.Items) && replayed with { Items = runtime.Model.Items } == runtime.Model;
Console.WriteLine($"same model: {same}, store calls: {store.Calls}");

sealed record TodoItem(int Id, string Title, bool Done);
sealed record Model(ImmutableList<TodoItem> Items, int NextId, bool Saving, string Note);

// 사용자 동작과 효과의 결과가 모두 메시지다.
abstract record Msg;
sealed record Add(string Title) : Msg;
sealed record Toggle(int Id) : Msg;
sealed record Save : Msg;
sealed record Saved(int Count) : Msg;
sealed record SaveFailed(string Reason) : Msg;
// Msg에 추가했지만 Update에 갈래를 만들지 않은 메시지다.
sealed record Undo : Msg;

// 명령: 런타임에게 맡길 효과를 설명하는 데이터다. Update는 실행하지 않는다.
abstract record Cmd;
sealed record NoCmd : Cmd;
sealed record SaveTodos(ImmutableList<TodoItem> Items) : Cmd;

static class Todo
{
    public static readonly Model Init = new([], 1, false, "");
    static readonly Cmd None = new NoCmd();

    public static (Model Model, Cmd Cmd) Update(Model model, Msg msg) => msg switch
    {
        Add a when string.IsNullOrWhiteSpace(a.Title) => (model with { Note = "title is empty" }, None),
        Add a => (model with
        {
            Items = model.Items.Add(new TodoItem(model.NextId, a.Title, false)),
            NextId = model.NextId + 1,
            Note = "",
        }, None),
        Toggle t when !model.Items.Any(i => i.Id == t.Id) => (model with { Note = $"no todo #{t.Id}" }, None),
        Toggle t => (model with
        {
            Items = model.Items.Select(i => i.Id == t.Id ? i with { Done = !i.Done } : i).ToImmutableList(),
            Note = "",
        }, None),
        // 저장 중에 다시 저장하면 명령을 만들지 않는다.
        Save when model.Saving => (model with { Note = "save already running" }, None),
        Save => (model with { Saving = true, Note = "" }, new SaveTodos(model.Items)),
        Saved s => (model with { Saving = false, Note = $"saved {s.Count}" }, None),
        SaveFailed f => (model with { Saving = false, Note = $"save failed: {f.Reason}" }, None),
        // 처리 갈래가 없는 메시지는 항목을 바꾸지 않고 메모만 남긴다.
        _ => (model with { Note = $"unhandled {msg.GetType().Name}" }, None),
    };

    public static string View(Model model)
    {
        string items = string.Join(", ", model.Items.Select(i => $"#{i.Id}[{(i.Done ? "x" : " ")}] {i.Title}"));
        string state = model.Saving ? "saving" : "idle";
        string note = model.Note == "" ? "" : $" | {model.Note}";
        return $"{items} | {state}{note}";
    }
}

// 런타임: 메시지를 기록하고 Update를 부른 뒤, 받은 명령은 나중에 실행하도록 쌓아 둔다.
sealed class Runtime(Model initial, Func<Cmd, Msg> execute)
{
    private readonly List<Msg> log = [];
    private readonly Queue<Cmd> pending = new();
    public Model Model { get; private set; } = initial;
    public IReadOnlyList<Msg> Log => log;

    public void Dispatch(Msg msg)
    {
        log.Add(msg);
        (Model, Cmd cmd) = Todo.Update(Model, msg);
        Console.WriteLine($"{msg} -> {Todo.View(Model)}");
        if (cmd is not NoCmd) pending.Enqueue(cmd);
    }

    // 효과의 결과는 새 메시지가 되어 다시 Update를 거친다.
    public void RunEffects()
    {
        while (pending.TryDequeue(out Cmd? cmd)) Dispatch(execute(cmd));
    }
}

sealed class FakeStore(bool[] outcomes)
{
    public int Calls { get; private set; }

    public Msg Run(Cmd cmd)
    {
        if (cmd is not SaveTodos save) return new SaveFailed($"unknown command {cmd.GetType().Name}");
        bool ok = outcomes[Calls];
        Calls++;
        Console.WriteLine($"  effect: save {save.Items.Count} items, call {Calls}");
        return ok ? new Saved(save.Items.Count) : new SaveFailed("disk full");
    }
}

Add { Title = buy milk } -> #1[ ] buy milk | idle
Add { Title =     } -> #1[ ] buy milk | idle | title is empty
Add { Title = write report } -> #1[ ] buy milk, #2[ ] write report | idle
Toggle { Id = 1 } -> #1[x] buy milk, #2[ ] write report | idle
Toggle { Id = 42 } -> #1[x] buy milk, #2[ ] write report | idle | no todo #42
Save { } -> #1[x] buy milk, #2[ ] write report | saving
Save { } -> #1[x] buy milk, #2[ ] write report | saving | save already running
  effect: save 2 items, call 1
SaveFailed { Reason = disk full } -> #1[x] buy milk, #2[ ] write report | idle | save failed: disk full
Save { } -> #1[x] buy milk, #2[ ] write report | saving
  effect: save 2 items, call 2
Saved { Count = 2 } -> #1[x] buy milk, #2[ ] write report | idle | saved 2
Undo { } -> #1[x] buy milk, #2[ ] write report | idle | unhandled Undo
log: 11 messages, store calls: 2
replay: #1[x] buy milk, #2[ ] write report | idle | unhandled Undo
same model: True, store calls: 2

type TodoItem = { readonly id: number; readonly title: string; readonly done: boolean };
type Model = {
  readonly items: readonly TodoItem[];
  readonly nextId: number;
  readonly saving: boolean;
  readonly note: string;
};

// 메시지와 명령은 kind 값으로 구별하는 판별 유니온이다.
type Msg =
  | { kind: "add"; title: string }
  | { kind: "toggle"; id: number }
  | { kind: "save" }
  | { kind: "saved"; count: number }
  | { kind: "saveFailed"; reason: string };
type Cmd = { kind: "none" } | { kind: "saveTodos"; items: readonly TodoItem[] };

const init: Model = { items: [], nextId: 1, saving: false, note: "" };
const none: Cmd = { kind: "none" };

function update(model: Model, msg: Msg): [Model, Cmd] {
  switch (msg.kind) {
    case "add":
      if (msg.title.trim() === "") return [{ ...model, note: "title is empty" }, none];
      return [{
        ...model,
        items: [...model.items, { id: model.nextId, title: msg.title, done: false }],
        nextId: model.nextId + 1,
        note: "",
      }, none];
    case "toggle":
      if (!model.items.some((i) => i.id === msg.id)) return [{ ...model, note: `no todo #${msg.id}` }, none];
      return [{ ...model, items: model.items.map((i) => (i.id === msg.id ? { ...i, done: !i.done } : i)), note: "" }, none];
    case "save":
      // 저장 중에 다시 저장하면 명령을 만들지 않는다.
      if (model.saving) return [{ ...model, note: "save already running" }, none];
      return [{ ...model, saving: true, note: "" }, { kind: "saveTodos", items: model.items }];
    case "saved":
      return [{ ...model, saving: false, note: `saved ${msg.count}` }, none];
    case "saveFailed":
      return [{ ...model, saving: false, note: `save failed: ${msg.reason}` }, none];
    default:
      // 모든 kind를 다루면 msg는 never가 된다. 갈래를 빠뜨리면 여기서 컴파일 오류가 난다.
      return assertNever(msg);
  }
}

function assertNever(value: never): never {
  throw new Error(`unhandled message ${JSON.stringify(value)}`);
}

function view(model: Model): string {
  const items = model.items.map((i) => `#${i.id}[${i.done ? "x" : " "}] ${i.title}`).join(", ");
  const note = model.note === "" ? "" : ` | ${model.note}`;
  return `${items} | ${model.saving ? "saving" : "idle"}${note}`;
}

// 가짜 저장소: 첫 저장은 실패하고 두 번째 저장은 성공한다.
class FakeStore {
  calls = 0;
  constructor(private readonly outcomes: readonly boolean[]) {}
  run(cmd: Cmd): Msg {
    if (cmd.kind !== "saveTodos") return { kind: "saveFailed", reason: `unknown command ${cmd.kind}` };
    const ok = this.outcomes[this.calls];
    this.calls++;
    console.log(`  effect: save ${cmd.items.length} items, call ${this.calls}`);
    return ok ? { kind: "saved", count: cmd.items.length } : { kind: "saveFailed", reason: "disk full" };
  }
}

// 런타임: 메시지를 기록하고 update를 부른 뒤, 받은 명령은 나중에 실행하도록 쌓아 둔다.
class Runtime {
  readonly log: Msg[] = [];
  private readonly pending: Cmd[] = [];
  constructor(public model: Model, private readonly execute: (cmd: Cmd) => Msg) {}
  dispatch(msg: Msg): void {
    this.log.push(msg);
    const [next, cmd] = update(this.model, msg);
    this.model = next;
    console.log(`${JSON.stringify(msg)} -> ${view(next)}`);
    if (cmd.kind !== "none") this.pending.push(cmd);
  }
  // 효과의 결과는 새 메시지가 되어 다시 update를 거친다.
  runEffects(): void {
    for (let cmd = this.pending.shift(); cmd !== undefined; cmd = this.pending.shift()) {
      this.dispatch(this.execute(cmd));
    }
  }
}

const store = new FakeStore([false, true]);
const runtime = new Runtime(init, (cmd) => store.run(cmd));
runtime.dispatch({ kind: "add", title: "buy milk" });
runtime.dispatch({ kind: "add", title: "   " });
runtime.dispatch({ kind: "add", title: "write report" });
runtime.dispatch({ kind: "toggle", id: 1 });
runtime.dispatch({ kind: "save" });
runtime.dispatch({ kind: "save" });
runtime.runEffects();
runtime.dispatch({ kind: "save" });
runtime.runEffects();

console.log(`log: ${runtime.log.length} messages, store calls: ${store.calls}`);
// 기록한 메시지를 처음 모델부터 다시 접는다. 명령은 실행하지 않는다.
const replayed = runtime.log.reduce((model, msg) => update(model, msg)[0], init);
console.log(`replay: ${view(replayed)}`);
// 두 모델은 같은 키 순서로 만들어지므로 JSON 문자열로 모델 전체를 비교한다.
console.log(`same model: ${JSON.stringify(replayed) === JSON.stringify(runtime.model)}, store calls: ${store.calls}`);

{"kind":"add","title":"buy milk"} -> #1[ ] buy milk | idle
{"kind":"add","title":"   "} -> #1[ ] buy milk | idle | title is empty
{"kind":"add","title":"write report"} -> #1[ ] buy milk, #2[ ] write report | idle
{"kind":"toggle","id":1} -> #1[x] buy milk, #2[ ] write report | idle
{"kind":"save"} -> #1[x] buy milk, #2[ ] write report | saving
{"kind":"save"} -> #1[x] buy milk, #2[ ] write report | saving | save already running
  effect: save 2 items, call 1
{"kind":"saveFailed","reason":"disk full"} -> #1[x] buy milk, #2[ ] write report | idle | save failed: disk full
{"kind":"save"} -> #1[x] buy milk, #2[ ] write report | saving
  effect: save 2 items, call 2
{"kind":"saved","count":2} -> #1[x] buy milk, #2[ ] write report | idle | saved 2
log: 9 messages, store calls: 2
replay: #1[x] buy milk, #2[ ] write report | idle | saved 2
same model: true, store calls: 2