모노이드

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

int[] counts = [3, 5, 2, 7];
decimal[] amounts = [1.10m, 2.20m, 3.30m];
Console.WriteLine(CombineAll(counts));
Console.WriteLine(CombineAll(amounts));
Console.WriteLine(CombineAll(Array.Empty<int>()));

// 정수 덧셈은 묶는 위치를 바꿔도 결과가 같다.
Console.WriteLine((1 + 2) + 3 == 1 + (2 + 3));
// 뺄셈은 묶는 위치에 따라 결과가 달라진다.
Console.WriteLine($"{(10 - 4) - 3} vs {10 - (4 - 3)}");
// double 덧셈은 매 단계 반올림하므로 묶는 위치에 따라 결과가 달라질 수 있다.
double left = (0.1 + 0.2) + 0.3;
double right = 0.1 + (0.2 + 0.3);
Console.WriteLine($"{left} vs {right}");
// 문자열 이어 붙이기는 결합법칙을 지키지만 순서를 바꾸면 결과가 달라진다.
Console.WriteLine(("a" + "b") + "c" == "a" + ("b" + "c"));
Console.WriteLine("a" + "b" == "b" + "a");

// 항등원 AdditiveIdentity(정수와 decimal에서는 0)에서 시작해 + 로 하나씩 합친다.
static T CombineAll<T>(IEnumerable<T> values)
    where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
    => values.Aggregate(T.AdditiveIdentity, (acc, x) => acc + x);

17
6.60
0
True
3 vs 9
0.6000000000000001 vs 0.6
True
False

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

// 주문 금액 배치 네 개. 세 번째는 빈 배치이고, 네 번째는 환불(음수)만 있다.
decimal[][] batches =
[
    [12.50m, 8.00m, 30.25m],
    [5.75m, 41.00m],
    [],
    [-3.00m, -7.50m],
];

OrderStats[] p = batches.Select(OrderStats.FromBatch).ToArray();
foreach (var s in p) Console.WriteLine($"batch    {s}");

// 같은 배치 결과를 세 가지 방식으로 묶는다.
var leftFirst = p.Aggregate(OrderStats.Empty, OrderStats.Combine);
var rightFirst = OrderStats.Combine(p[0], OrderStats.Combine(p[1], OrderStats.Combine(p[2], p[3])));
var pairwise = OrderStats.Combine(OrderStats.Combine(p[0], p[1]), OrderStats.Combine(p[2], p[3]));
// PLINQ는 주문을 파티션으로 나눠 부분 결과를 만들고, 그 부분 결과를 Combine으로 합친다.
var parallel = batches.SelectMany(b => b).AsParallel().Aggregate(
    () => OrderStats.Empty,
    (acc, amount) => OrderStats.Combine(acc, OrderStats.Of(amount)),
    OrderStats.Combine,
    s => s);
Console.WriteLine($"left     {leftFirst}");
Console.WriteLine($"right    {rightFirst}");
Console.WriteLine($"pairwise {pairwise}");
Console.WriteLine($"parallel {parallel}");
Console.WriteLine(leftFirst == rightFirst && rightFirst == pairwise && pairwise == parallel);

// 중립이 아닌 시작값: Max를 0으로 두면 환불만 있는 배치의 최댓값이 0으로 바뀐다.
var notNeutral = new OrderStats(0, 0m, 0m);
Console.WriteLine($"empty    {OrderStats.Combine(OrderStats.Empty, p[3])}");
Console.WriteLine($"wrong    {OrderStats.Combine(notNeutral, p[3])}");

// 평균끼리 평균을 내는 합치기는 결합법칙을 지키지 않는다.
static decimal Avg(decimal a, decimal b) => (a + b) / 2;
Console.WriteLine($"{Avg(Avg(10m, 20m), 60m)} vs {Avg(10m, Avg(20m, 60m))}");
// 개수와 합계를 모아 두면 평균은 마지막에 한 번만 계산하면 된다.
var three = new[] { 10m, 20m, 60m }.Aggregate(OrderStats.Empty, (acc, x) => OrderStats.Combine(acc, OrderStats.Of(x)));
Console.WriteLine(three.Sum / three.Count);

record OrderStats(int Count, decimal Sum, decimal? Max)
{
    // 항등원: 어떤 값과 합쳐도 그 값을 바꾸지 않는다. 주문이 없으면 최댓값도 없다(null).
    public static readonly OrderStats Empty = new(0, 0m, null);

    public static OrderStats Of(decimal amount) => new(1, amount, amount);

    public static OrderStats FromBatch(decimal[] batch) =>
        batch.Aggregate(Empty, (acc, x) => Combine(acc, Of(x)));

    // 결합법칙을 지키는 합치기: 개수와 합계는 더하고, 최댓값은 큰 쪽을 고른다.
    public static OrderStats Combine(OrderStats a, OrderStats b) =>
        new(a.Count + b.Count, a.Sum + b.Sum, (a.Max, b.Max) switch
        {
            (null, _) => b.Max,
            (_, null) => a.Max,
            _ => Math.Max(a.Max.Value, b.Max.Value),
        });

    public override string ToString() => $"count={Count}, sum={Sum}, max={Max?.ToString() ?? "none"}";
}

batch    count=3, sum=50.75, max=30.25
batch    count=2, sum=46.75, max=41.00
batch    count=0, sum=0, max=none
batch    count=2, sum=-10.50, max=-3.00
left     count=7, sum=87.00, max=41.00
right    count=7, sum=87.00, max=41.00
pairwise count=7, sum=87.00, max=41.00
parallel count=7, sum=87.00, max=41.00
True
empty    count=2, sum=-10.50, max=-3.00
wrong    count=2, sum=-10.50, max=0
37.5 vs 25
30

type OrderStats = { readonly count: number; readonly sum: number; readonly max: number | null };

// 항등원: 주문이 없으면 개수와 합계는 0이고 최댓값은 없다.
const empty: OrderStats = { count: 0, sum: 0, max: null };

function of(cents: number): OrderStats {
  return { count: 1, sum: cents, max: cents };
}

// 결합법칙을 지키는 합치기: 개수와 합계는 더하고, 최댓값은 큰 쪽을 고른다.
function combine(a: OrderStats, b: OrderStats): OrderStats {
  const max = a.max === null ? b.max : b.max === null ? a.max : Math.max(a.max, b.max);
  return { count: a.count + b.count, sum: a.sum + b.sum, max };
}

function show(s: OrderStats): string {
  return `count=${s.count}, sum=${s.sum}, max=${s.max ?? "none"}`;
}

// 금액은 정수 센트로 둔다. 소수 금액을 number(double)로 더하면 결합법칙이 깨질 수 있다.
const batches: number[][] = [[1250, 800, 3025], [575, 4100], [], [-300, -750]];
const p = batches.map((batch) => batch.map(of).reduce(combine, empty));

const leftFirst = p.reduce(combine, empty);
const rightFirst = p.reduceRight((acc, s) => combine(s, acc), empty);
const pairwise = combine(combine(p[0], p[1]), combine(p[2], p[3]));
console.log("left     " + show(leftFirst));
console.log("right    " + show(rightFirst));
console.log("pairwise " + show(pairwise));
console.log(show(leftFirst) === show(rightFirst) && show(rightFirst) === show(pairwise));

// 빈 목록도 항등원이 있으면 결과가 정해진다. 시작값 없는 reduce는 TypeError를 던진다.
const none: OrderStats[] = [];
console.log("empty    " + show(none.reduce(combine, empty)));
try {
  none.reduce(combine);
} catch (e) {
  console.log(e instanceof TypeError ? "TypeError: " + e.message : "unexpected");
}

console.log((0.1 + 0.2) + 0.3, 0.1 + (0.2 + 0.3));

left     count=7, sum=8700, max=4100
right    count=7, sum=8700, max=4100
pairwise count=7, sum=8700, max=4100
true
empty    count=0, sum=0, max=none
TypeError: Reduce of empty array with no initial value
0.6000000000000001 0.6