폴드

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

int[] numbers = [1, 2, 3];

// Aggregate는 왼쪽 폴드다. 앞 원소부터 누산기를 갱신한다.
string leftText = numbers.Aggregate("0", (acc, x) => $"({acc} - {x})");
int left = numbers.Aggregate(0, (acc, x) => acc - x);
// LINQ에는 오른쪽 폴드가 없어서 뒤에서부터 접는 함수를 직접 둔다.
string rightText = FoldRight(numbers, "0", (x, acc) => $"({x} - {acc})");
int right = FoldRight(numbers, 0, (x, acc) => x - acc);
Console.WriteLine($"left:  {leftText} = {left}");
Console.WriteLine($"right: {rightText} = {right}");

// 이어 붙이기는 묶는 순서가 달라도 결과가 같다.
string[] letters = ["a", "b", "c"];
string leftConcat = letters.Aggregate("", (acc, s) => acc + s);
string rightConcat = FoldRight(letters, "", (s, acc) => s + acc);
Console.WriteLine($"concat: {leftConcat} / {rightConcat}");

// 오른쪽 폴드: 마지막 원소와 초기값을 먼저 결합하고 앞쪽으로 진행한다.
static TAcc FoldRight<T, TAcc>(IReadOnlyList<T> items, TAcc seed, Func<T, TAcc, TAcc> step)
{
    TAcc acc = seed;
    for (int i = items.Count - 1; i >= 0; i--) acc = step(items[i], acc);
    return acc;
}

left:  (((0 - 1) - 2) - 3) = -6
right: (1 - (2 - (3 - 0))) = 2
concat: abc / abc

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

Order[] orders =
[
    new("A-1", 2, 15_000m),
    new("A-2", 1, 42_000m),
    new("A-3", 3, 8_000m),
];
Order[] none = [];

// 주문 요약: Aggregate 한 번으로 건수, 수량, 합계, 가장 큰 주문을 함께 구한다.
Console.WriteLine(orders.Aggregate(Summary.Empty, Summary.Include));
Console.WriteLine(none.Aggregate(Summary.Empty, Summary.Include));

// 빈 입력: 초기값이 없는 Aggregate와 Max는 예외를 던지고, Sum은 0을 돌려준다.
Report("Aggregate(no seed)", () => none.Select(o => o.Amount).Aggregate((a, b) => a + b));
Report("Max", () => none.Max(o => o.Amount));
Report("Sum", () => none.Sum(o => o.Amount));

// 식 트리 폴드: 생성자마다 처리 함수를 하나씩 받는다.
Expr expr = new Mul(new Add(new Num(2), new Num(3)), new Num(4));
int value = Fold(expr, n => n, (l, r) => l + r, (l, r) => l * r);
string text = Fold(expr, n => n.ToString(), (l, r) => $"({l} + {r})", (l, r) => $"{l} * {r}");
int depth = Fold(expr, _ => 1, (l, r) => 1 + Math.Max(l, r), (l, r) => 1 + Math.Max(l, r));
Console.WriteLine($"{text} = {value}, depth {depth}");

static void Report(string label, Func<decimal> run)
{
    try
    {
        Console.WriteLine($"{label}: {run()}");
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"{label}: {ex.GetType().Name}: {ex.Message}");
    }
}

// C#에는 닫힌 합 타입이 없어서 마지막 갈래가 필요하다.
static T Fold<T>(Expr e, Func<int, T> num, Func<T, T, T> add, Func<T, T, T> mul) => e switch
{
    Num n => num(n.Value),
    Add a => add(Fold(a.Left, num, add, mul), Fold(a.Right, num, add, mul)),
    Mul m => mul(Fold(m.Left, num, add, mul), Fold(m.Right, num, add, mul)),
    _ => throw new ArgumentOutOfRangeException(nameof(e), e, "unknown node"),
};

sealed record Order(string Id, int Quantity, decimal UnitPrice)
{
    public decimal Amount => Quantity * UnitPrice;
}

// 누산기: 지금까지 본 주문의 요약을 담는 불변 값이다.
sealed record Summary(int Count, int Quantity, decimal Total, Order? Largest)
{
    public static readonly Summary Empty = new(0, 0, 0m, null);

    public static Summary Include(Summary acc, Order o) => new(
        acc.Count + 1,
        acc.Quantity + o.Quantity,
        acc.Total + o.Amount,
        acc.Largest is null || o.Amount > acc.Largest.Amount ? o : acc.Largest);

    public override string ToString() =>
        $"orders={Count} qty={Quantity} total={Total} largest={Largest?.Id ?? "(none)"}";
}

abstract record Expr;
sealed record Num(int Value) : Expr;
sealed record Add(Expr Left, Expr Right) : Expr;
sealed record Mul(Expr Left, Expr Right) : Expr;

orders=3 qty=6 total=96000 largest=A-2
orders=0 qty=0 total=0 largest=(none)
Aggregate(no seed): InvalidOperationException: Sequence contains no elements
Max: InvalidOperationException: Sequence contains no elements
Sum: 0
(2 + 3) * 4 = 20, depth 3

const numbers = [1, 2, 3];

// reduce는 왼쪽 폴드, reduceRight는 오른쪽 폴드다.
const leftText = numbers.reduce((acc, x) => `(${acc} - ${x})`, "0");
const rightText = numbers.reduceRight((acc, x) => `(${x} - ${acc})`, "0");
console.log(`left:  ${leftText} = ${numbers.reduce((acc, x) => acc - x, 0)}`);
console.log(`right: ${rightText} = ${numbers.reduceRight((acc, x) => x - acc, 0)}`);

// 빈 배열: 초기값이 없으면 TypeError, 있으면 초기값이 그대로 결과가 된다.
const empty: number[] = [];
try {
  console.log(empty.reduce((a, b) => a + b));
} catch (e) {
  if (!(e instanceof TypeError)) throw e;
  console.log(`no seed: ${e.name}: ${e.message}`);
}
console.log(`seed 0: ${empty.reduce((a, b) => a + b, 0)}`);

type Expr =
  | { kind: "num"; value: number }
  | { kind: "add"; left: Expr; right: Expr }
  | { kind: "mul"; left: Expr; right: Expr };

// 식 트리 폴드: 생성자마다 처리 함수를 하나씩 받는다.
function fold<T>(e: Expr, num: (v: number) => T, add: (l: T, r: T) => T, mul: (l: T, r: T) => T): T {
  switch (e.kind) {
    case "num": return num(e.value);
    case "add": return add(fold(e.left, num, add, mul), fold(e.right, num, add, mul));
    case "mul": return mul(fold(e.left, num, add, mul), fold(e.right, num, add, mul));
  }
}

const n = (value: number): Expr => ({ kind: "num", value });
const expr: Expr = { kind: "mul", left: { kind: "add", left: n(2), right: n(3) }, right: n(4) };
const value = fold(expr, (v) => v, (l, r) => l + r, (l, r) => l * r);
const text = fold(expr, (v) => String(v), (l, r) => `(${l} + ${r})`, (l, r) => `${l} * ${r}`);
console.log(`${text} = ${value}`);

left:  (((0 - 1) - 2) - 3) = -6
right: (1 - (2 - (3 - 0))) = 2
no seed: TypeError: Reduce of empty array with no initial value
seed 0: 0
(2 + 3) * 4 = 20