Functional techniques in C#

// The same checkout total worked out twice. The impure version changes the lines it is given and a static flag, so
// the same call gives another answer the second time; the pure one only reads its input. The prices, the 10 % offer
// and the Rs 50 first-order discount are made up for this lesson.
using System.Collections.Immutable;

var mutable = new List<MutableLine> { new("Tea 250 g", 2, 180m), new("Rice 5 kg", 1, 450m) };
Console.WriteLine($"impure: Rs {Impure.Total(mutable)}, then Rs {Impure.Total(mutable)} for the same cart");
Console.WriteLine($"  the cart's tea now costs Rs {mutable[0].Price} a pack");

ImmutableList<Line> cart = [new("Tea 250 g", 2, 180m), new("Rice 5 kg", 1, 450m)];
Console.WriteLine($"pure:   Rs {Pure.Total(cart, firstOrder: true)}, then Rs {Pure.Total(cart, firstOrder: true)} for the same cart");

// A change is a new value: with makes a new line, SetItem a new list. The old cart is as it was.
ImmutableList<Line> moreTea = cart.SetItem(0, cart[0] with { Quantity = 3 });
Console.WriteLine($"  3 packs of tea: Rs {Pure.Total(moreTea, firstOrder: true)}; the old cart still has {cart[0].Quantity} and costs Rs {Pure.Total(cart, firstOrder: true)}");

// An expression, not a statement: a switch expression picks the GST rate, and a throw expression rejects the rest.
Console.WriteLine($"GST on essentials: {Pure.GstPercent("essentials")} %, on standard goods: {Pure.GstPercent("standard")} %");

record Line(string Name, int Quantity, decimal Price);

class MutableLine(string name, int quantity, decimal price)
{
    public string Name { get; } = name;

    public int Quantity { get; } = quantity;

    public decimal Price { get; set; } = price;
}

static class Impure
{
    private static bool s_firstOrderUsed;

    // Takes 10 % off by changing each line's price, and gives Rs 50 off the first order it ever sees.
    public static decimal Total(List<MutableLine> lines)
    {
        foreach (MutableLine line in lines)
        {
            line.Price = line.Price * 90 / 100;
        }

        decimal total = lines.Sum(line => line.Quantity * line.Price);
        if (!s_firstOrderUsed)
        {
            s_firstOrderUsed = true;
            total -= 50m;
        }

        return total;
    }
}

static class Pure
{
    // Reads its arguments, changes nothing, and returns the same total for the same arguments.
    public static decimal Total(IReadOnlyList<Line> lines, bool firstOrder)
    {
        decimal subtotal = lines.Sum(line => line.Quantity * line.Price);
        decimal afterOffer = subtotal * 90 / 100;
        return firstOrder ? afterOffer - 50m : afterOffer;
    }

    public static decimal GstPercent(string category) => category switch
    {
        "essentials" => 5m,
        "standard" => 18m,
        _ => throw new ArgumentOutOfRangeException(nameof(category), category, "no GST rate for this category"),
    };
}

impure: Rs 679, then Rs 656.1 for the same cart
  the cart's tea now costs Rs 145.8 a pack
pure:   Rs 679, then Rs 679 for the same cart
  3 packs of tea: Rs 841; the old cart still has 2 and costs Rs 679
GST on essentials: 5 %, on standard goods: 18 %

// Functions as values: a method that takes a function, methods that return functions, and a C# 14 extension member,
// Then, that joins two functions into one. The prices and rates are made up for this lesson.
List<Line> cart = [new("Tea 250 g", 2, 180m), new("Rice 5 kg", 1, 450m)];

// A function that takes a function: Apply runs any rule on every line.
Console.WriteLine($"each line at 10 % off: {string.Join(", ", Apply(cart, PercentOff(10)))}");

// Functions that return functions: PercentOff(10) and AddGst(5) fix one argument now and wait for the amount.
Func<decimal, decimal> festival = PercentOff(10);
Func<decimal, decimal> gst = AddGst(5);
Console.WriteLine($"festival(810) = {festival(810m)}, gst(729) = {gst(729m)}");

// Then joins functions: each step's result is the next step's input, read left to right.
Func<IReadOnlyList<Line>, decimal> subtotal = Subtotal;
Func<IReadOnlyList<Line>, decimal> checkout = subtotal.Then(festival).Then(gst).Then(RoundToRupee);
Console.WriteLine($"checkout(cart) = Rs {checkout(cart)}");

// The same steps in another order are another function, with another result.
Func<IReadOnlyList<Line>, decimal> roundFirst = subtotal.Then(RoundToRupee).Then(gst).Then(festival);
Console.WriteLine($"rounding first = Rs {roundFirst(cart)}");

static IEnumerable<decimal> Apply(IEnumerable<Line> lines, Func<decimal, decimal> rule) =>
    lines.Select(line => rule(line.Quantity * line.Price));

static decimal Subtotal(IReadOnlyList<Line> lines) => lines.Sum(line => line.Quantity * line.Price);

static Func<decimal, decimal> PercentOff(int percent) => amount => amount * (100 - percent) / 100;

static Func<decimal, decimal> AddGst(int percent) => amount => amount + amount * percent / 100;

static decimal RoundToRupee(decimal amount) => Math.Round(amount, 0, MidpointRounding.AwayFromZero);

record Line(string Name, int Quantity, decimal Price);

static class FunctionExtensions
{
    // A C# 14 extension block: Then becomes a member of every Func<T, TResult>.
    extension<T, TResult>(Func<T, TResult> first)
    {
        public Func<T, TNext> Then<TNext>(Func<TResult, TNext> next) => value => next(first(value));
    }
}

each line at 10 % off: 324, 405
festival(810) = 729, gst(729) = 765.45
checkout(cart) = Rs 765
rounding first = Rs 765.45

// Practice: write the four methods of Pricing and Carts, then run this file until all eight checks pass. What each
// must do is in the comment above it. The prices and rates are made up for this exercise.
using System.Collections.Immutable;

ImmutableList<Line> cart = [new("Tea 250 g", 2, 180m), new("Rice 5 kg", 1, 450m)];

(string Check, Func<string> Run, string Expected)[] checks =
[
    ("PercentOff(10) takes 10 % off", () => Pricing.PercentOff(10)(1000m).ToString(), "900"),
    ("AddGst(18) adds 18 %", () => Pricing.AddGst(18)(1000m).ToString(), "1180"),
    ("Checkout applies the offer, then GST, then rounds", () => Pricing.Checkout(cart, offerPercent: 10, gstPercent: 5).ToString(), "765"),
    ("Checkout gives the same total twice", () => $"{Pricing.Checkout(cart, 10, 5)} and {Pricing.Checkout(cart, 10, 5)}", "765 and 765"),
    ("Checkout leaves the cart as it was", () => { Pricing.Checkout(cart, 10, 5); return $"{cart.Count} lines, {cart[0].Quantity} packs of tea"; }, "2 lines, 2 packs of tea"),
    ("WithQuantity returns a changed cart", () => Carts.WithQuantity(cart, "Tea 250 g", 3)[0].Quantity.ToString(), "3"),
    ("WithQuantity leaves the old cart as it was", () => { Carts.WithQuantity(cart, "Tea 250 g", 3); return cart[0].Quantity.ToString(); }, "2"),
    ("an unknown item gives back the same cart", () => ReferenceEquals(Carts.WithQuantity(cart, "Salt 1 kg", 1), cart) ? "same cart" : "another cart", "same cart"),
];

int passed = 0;
foreach (var (check, run, expected) in checks)
{
    string got;
    try
    {
        got = run();
    }
    catch (Exception e)
    {
        got = $"throws {e.GetType().Name}";
    }

    bool ok = got == expected;
    if (ok)
    {
        passed++;
    }

    Console.WriteLine(ok ? $"{check}: ok" : $"{check}: FAIL, {got} instead of {expected}");
}

Console.WriteLine($"{passed} of {checks.Length} checks pass");
return passed == checks.Length ? 0 : 1;

record Line(string Name, int Quantity, decimal Price);

static class Pricing
{
    // Returns a function that takes percent per cent off an amount.
    public static Func<decimal, decimal> PercentOff(int percent) => throw new NotImplementedException();

    // Returns a function that adds percent per cent of GST to an amount.
    public static Func<decimal, decimal> AddGst(int percent) => throw new NotImplementedException();

    // The subtotal of the lines, then the offer, then GST, then rounded to the rupee (midpoints away from zero).
    // Pure: it reads its arguments and changes nothing.
    public static decimal Checkout(IReadOnlyList<Line> lines, int offerPercent, int gstPercent) => throw new NotImplementedException();
}

static class Carts
{
    // Returns a cart in which the line with this name has the new quantity; the cart passed in does not change. When no
    // line has this name, returns the very same cart.
    public static ImmutableList<Line> WithQuantity(ImmutableList<Line> cart, string name, int quantity) => throw new NotImplementedException();
}

PercentOff(10) takes 10 % off: FAIL, throws NotImplementedException instead of 900
AddGst(18) adds 18 %: FAIL, throws NotImplementedException instead of 1180
Checkout applies the offer, then GST, then rounds: FAIL, throws NotImplementedException instead of 765
Checkout gives the same total twice: FAIL, throws NotImplementedException instead of 765 and 765
Checkout leaves the cart as it was: FAIL, throws NotImplementedException instead of 2 lines, 2 packs of tea
WithQuantity returns a changed cart: FAIL, throws NotImplementedException instead of 3
WithQuantity leaves the old cart as it was: FAIL, throws NotImplementedException instead of 2
an unknown item gives back the same cart: FAIL, throws NotImplementedException instead of same cart
0 of 8 checks pass