펑터

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

int[] prices = [12000, 0, 45000];

// Select는 각 원소에만 함수를 적용하고, 원소 수와 순서는 그대로 둔다.
var withShipping = prices.Select(p => p + 3000);

// 쿼리 구문도 컴파일러가 withShipping.Select(p => $"{p} KRW")로 바꾼다.
var labels = from p in withShipping select $"{p} KRW";

Console.WriteLine(string.Join(", ", withShipping));
Console.WriteLine(string.Join(", ", labels));
Console.WriteLine($"count: {prices.Length} -> {labels.Count()}");

15000, 3000, 48000
15000 KRW, 3000 KRW, 48000 KRW
count: 3 -> 3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

Func<int, int> addShipping = p => p + 3000;
Func<int, string> format = p => $"{p} KRW";
Func<int, string> addThenFormat = p => format(addShipping(p));

// 같은 두 함수를 리스트, Option, Result에 그대로 적용한다.
int[] prices = [12000, 0];
Option<int>[] options = [new Option<int>.Some(12000), new Option<int>.None()];
Result<int>[] results = [new Result<int>.Ok(12000), new Result<int>.Err("price missing")];

Console.WriteLine(string.Join(", ", prices.Select(addShipping).Select(format)));
foreach (var o in options) Console.WriteLine(o.Select(addShipping).Select(format));
foreach (var r in results) Console.WriteLine(r.Select(addShipping).Select(format));

// 항등 법칙: Select(x => x)는 원래 값과 같다.
// 합성 법칙: Select(addThenFormat)는 Select(addShipping).Select(format)과 같다.
var listComp = prices.Select(addThenFormat).SequenceEqual(prices.Select(addShipping).Select(format));
Console.WriteLine($"list: id={prices.Select(x => x).SequenceEqual(prices)}, comp={listComp}");
foreach (var o in options)
{
    var comp = o.Select(addThenFormat).Equals(o.Select(addShipping).Select(format));
    Console.WriteLine($"option: id={o.Select(x => x).Equals(o)}, comp={comp}");
}
foreach (var r in results)
{
    var comp = r.Select(addThenFormat).Equals(r.Select(addShipping).Select(format));
    Console.WriteLine($"result: id={r.Select(x => x).Equals(r)}, comp={comp}");
}

// Select만 있으면 쿼리 구문이 Option과 Task에도 쓰인다.
Console.WriteLine(from p in options[0] select addThenFormat(p));
Console.WriteLine(await (from p in Task.FromResult(12000) select addThenFormat(p)));

// 컴파일러는 법칙을 검사하지 않는다. 첫 원소를 버리는 Select도 그대로 컴파일된다.
var batch = new LossyBatch<int>([12000, 0]);
var same = from x in batch select x;
Console.WriteLine($"lossy: {string.Join(", ", same.Items)}, id={same.Items.SequenceEqual(batch.Items)}");

abstract record Option<T>
{
    public abstract Option<U> Select<U>(Func<T, U> f);

    // 값이 있을 때만 f를 부른다.
    public sealed record Some(T Value) : Option<T>
    {
        public override Option<U> Select<U>(Func<T, U> f) => new Option<U>.Some(f(Value));
    }

    // 값이 없으면 f를 부르지 않고 None을 돌려준다.
    public sealed record None : Option<T>
    {
        public override Option<U> Select<U>(Func<T, U> f) => new Option<U>.None();
    }
}

abstract record Result<T>
{
    public abstract Result<U> Select<U>(Func<T, U> f);

    // 성공 값에만 f를 적용한다.
    public sealed record Ok(T Value) : Result<T>
    {
        public override Result<U> Select<U>(Func<T, U> f) => new Result<U>.Ok(f(Value));
    }

    // 실패는 f를 부르지 않고 같은 오류 메시지로 넘긴다.
    public sealed record Err(string Error) : Result<T>
    {
        public override Result<U> Select<U>(Func<T, U> f) => new Result<U>.Err(Error);
    }
}

static class TaskFunctor
{
    // await로 결과를 꺼내 f를 적용한다. 작업이 실패하면 await가 그 예외를 다시 던진다.
    public static async Task<U> Select<T, U>(this Task<T> task, Func<T, U> f) => f(await task);
}

// 법칙을 어기는 Select: 구조(원소 수)를 바꾼다.
sealed class LossyBatch<T>(T[] items)
{
    public T[] Items => items;
    public LossyBatch<U> Select<U>(Func<T, U> f) => new(items.Skip(1).Select(f).ToArray());
}

15000 KRW, 3000 KRW
Some { Value = 15000 KRW }
None { }
Ok { Value = 15000 KRW }
Err { Error = price missing }
list: id=True, comp=True
option: id=True, comp=True
option: id=True, comp=True
result: id=True, comp=True
result: id=True, comp=True
Some { Value = 15000 KRW }
15000 KRW
lossy: 0, id=False

type Option<T> = { kind: "some"; value: T } | { kind: "none" };
type Result<T> = { kind: "ok"; value: T } | { kind: "err"; error: string };

// 값이 있을 때만 f를 부르고, 없으면 none을 그대로 돌려준다.
function mapOption<T, U>(o: Option<T>, f: (x: T) => U): Option<U> {
  return o.kind === "some" ? { kind: "some", value: f(o.value) } : o;
}
// 실패는 f를 부르지 않고 같은 오류로 넘긴다.
function mapResult<T, U>(r: Result<T>, f: (x: T) => U): Result<U> {
  return r.kind === "ok" ? { kind: "ok", value: f(r.value) } : r;
}

const addShipping = (p: number): number => p + 3000;
const format = (p: number): string => `${p} KRW`;
const addThenFormat = (p: number): string => format(addShipping(p));
const id = <T>(x: T): T => x;
const same = (a: unknown, b: unknown): boolean => JSON.stringify(a) === JSON.stringify(b);

const prices = [12000, 0];
const options: Option<number>[] = [{ kind: "some", value: 12000 }, { kind: "none" }];
const results: Result<number>[] = [{ kind: "ok", value: 12000 }, { kind: "err", error: "price missing" }];

console.log(prices.map(addShipping).map(format).join(", "));
for (const o of options) console.log(JSON.stringify(mapOption(mapOption(o, addShipping), format)));
for (const r of results) console.log(JSON.stringify(mapResult(mapResult(r, addShipping), format)));

// 항등 법칙과 합성 법칙을 값으로 비교한다.
const listComp = same(prices.map(addThenFormat), prices.map(addShipping).map(format));
console.log(`list: id=${same(prices.map(id), prices)}, comp=${listComp}`);
for (const o of options) {
  const comp = same(mapOption(o, addThenFormat), mapOption(mapOption(o, addShipping), format));
  console.log(`option: id=${same(mapOption(o, id), o)}, comp=${comp}`);
}
for (const r of results) {
  const comp = same(mapResult(r, addThenFormat), mapResult(mapResult(r, addShipping), format));
  console.log(`result: id=${same(mapResult(r, id), r)}, comp=${comp}`);
}

15000 KRW, 3000 KRW
{"kind":"some","value":"15000 KRW"}
{"kind":"none"}
{"kind":"ok","value":"15000 KRW"}
{"kind":"err","error":"price missing"}
list: id=true, comp=true
option: id=true, comp=true
option: id=true, comp=true
result: id=true, comp=true
result: id=true, comp=true