부분 적용과 커링

using System;

// 세율과 가격을 한꺼번에 받는 원래 함수
Func<decimal, decimal, decimal> addTax = (rate, price) => price * (1 + rate);

// 부분 적용: rate를 0.10으로 고정하고 price만 받는 새 함수를 만든다.
Func<decimal, decimal> withVat = price => addTax(0.10m, price);

// 커링: rate를 받으면 price를 받는 함수를 돌려주는 형태로 바꾼다.
Func<decimal, Func<decimal, decimal>> addTaxCurried = rate => price => price * (1 + rate);

Console.WriteLine(addTax(0.10m, 1000m));
Console.WriteLine(withVat(1000m));
Console.WriteLine(addTaxCurried(0.10m)(1000m));

1100.00
1100.00
1100.00

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

// 실행 환경의 지역 설정과 관계없이 같은 출력이 나오도록 고정한다.
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// 통화, 소수 자릿수, 금액을 하나씩 받도록 커링한 포매터
Func<string, Func<int, Func<decimal, string>>> formatPrice =
    currency => decimals => amount => currency + " " + amount.ToString("N" + decimals);

// 통화와 자릿수는 한 번만 정하고, 만든 함수를 Select에 그대로 넘긴다.
Func<decimal, string> krw = formatPrice("KRW")(0);
Func<decimal, string> usd = formatPrice("USD")(2);
decimal[] prices = [1200m, 3450.5m];
Console.WriteLine(string.Join(" | ", prices.Select(krw)));
Console.WriteLine(string.Join(" | ", prices.Select(usd)));

// 고정할 값은 함수를 만들 때 한 번만 검증한다.
foreach (var rate in new[] { 0.10m, 1.5m })
{
    var calculator = TaxCalculator(rate);
    Console.WriteLine(calculator is null
        ? $"rate {rate}: rejected"
        : $"rate {rate}: {calculator(1000m)}");
}

// 람다는 값이 아니라 변수를 캡처한다.
var settings = new TaxSettings { Rate = 0.10m };
Func<decimal, decimal> live = price => price * (1 + settings.Rate);
var fixedRate = settings.Rate; // 지금 값을 지역 변수에 복사해 둔다.
Func<decimal, decimal> snapshot = price => price * (1 + fixedRate);
settings.Rate = 0.20m;
Console.WriteLine($"live: {live(1000m)}, snapshot: {snapshot(1000m)}");

// for의 i는 반복 전체에서 변수 하나이고, foreach의 n은 반복마다 새 변수다.
var fromFor = new List<Func<int>>();
for (var i = 0; i < 3; i++) fromFor.Add(() => i);
var fromForeach = new List<Func<int>>();
foreach (var n in new[] { 0, 1, 2 }) fromForeach.Add(() => n);
Console.WriteLine("for: " + string.Join(",", fromFor.Select(f => f())));
Console.WriteLine("foreach: " + string.Join(",", fromForeach.Select(f => f())));

// 세율이 0과 1 사이가 아니면 계산 함수를 만들지 않는다.
static Func<decimal, decimal>? TaxCalculator(decimal rate) =>
    rate is < 0m or > 1m
        ? null
        : price => decimal.Round(price * (1 + rate), 0, MidpointRounding.AwayFromZero);

sealed class TaxSettings
{
    public decimal Rate { get; set; }
}

KRW 1,200 | KRW 3,451
USD 1,200.00 | USD 3,450.50
rate 0.10: 1100
rate 1.5: rejected
live: 1200.00, snapshot: 1100.00
for: 3,3,3
foreach: 0,1,2

// 통화, 소수 자릿수, 금액을 하나씩 받도록 커링한 포매터
const formatPrice = (currency: string) => (decimals: number) => (amount: number): string =>
  currency + " " + amount.toLocaleString("en-US", {
    minimumFractionDigits: decimals,
    maximumFractionDigits: decimals,
  });

const krw = formatPrice("KRW")(0);
const usd = formatPrice("USD")(2);
const prices = [1200, 3450.5];
console.log(prices.map(krw).join(" | "));
console.log(prices.map(usd).join(" | "));

// bind는 JavaScript에 내장된 부분 적용이다. 앞쪽 인자부터 고정한다.
function addTax(rate: number, price: number): number {
  return Math.round(price * (1 + rate)); // number는 부동소수점이라 정수로 반올림한다.
}
const withVat = addTax.bind(null, 0.1);
console.log("withVat: " + withVat(1000));

// 클로저는 객체를 나중에 읽으므로, 고정하려면 지금 값을 복사한다.
const settings = { rate: 0.1 };
const live = (price: number) => Math.round(price * (1 + settings.rate));
const fixedRate = settings.rate;
const snapshot = (price: number) => Math.round(price * (1 + fixedRate));
settings.rate = 0.2;
console.log(`live: ${live(1000)}, snapshot: ${snapshot(1000)}`);

// var는 반복 전체에서 변수 하나이고, let은 반복마다 새 바인딩을 만든다.
const fromVar: Array<() => number> = [];
for (var i = 0; i < 3; i++) fromVar.push(() => i);
const fromLet: Array<() => number> = [];
for (let j = 0; j < 3; j++) fromLet.push(() => j);
console.log("var: " + fromVar.map((f) => f()).join(","));
console.log("let: " + fromLet.map((f) => f()).join(","));

KRW 1,200 | KRW 3,451
USD 1,200.00 | USD 3,450.50
withVat: 1100
live: 1200, snapshot: 1100
var: 3,3,3
let: 0,1,2