Lambdas and closures

// Lambdas in their common forms. Each one becomes a delegate; with var, the compiler chooses the delegate type.
using System.Globalization;

Func<int, int> square = x => x * x;              // an expression lambda: its body is one expression
Action<string> greet = name =>                    // a statement lambda: a block of statements
{
    string text = $"Namaste, {name}";
    Console.WriteLine(text);
};
Func<int, int, bool> divides = (d, n) => n % d == 0;   // two parameters need parentheses
Func<string> today = () => "Saturday";                  // no parameters: empty parentheses

Console.WriteLine($"square(12) = {square(12)}");
greet("Asha");
Console.WriteLine($"3 divides 12: {divides(3, 12)}, today: {today()}");

// A natural type (C# 10): with var and typed parameters, the compiler infers Func<...> or Action<...>.
var parse = (string s) => int.Parse(s, CultureInfo.InvariantCulture);
var shout = (string s) => Console.WriteLine(s.ToUpperInvariant());
Console.WriteLine($"parse is a {Name(parse.GetType())}; shout is an {Name(shout.GetType())}");
shout("platform 4");

// An explicit return type, for branches that have no type in common.
var status = object (bool paid) => paid ? 1 : "pending";
Console.WriteLine($"status is a {Name(status.GetType())}: {status(true)}, {status(false)}");

// A method group with exactly one overload has a natural type as well.
var isBlank = string.IsNullOrWhiteSpace;
Console.WriteLine($"isBlank is a {Name(isBlank.GetType())}: {isBlank("   ")}");

// The type names as C# writes them, for printing.
static string Name(Type type)
{
    string name = type.Name switch
    {
        "Int32" => "int",
        "String" => "string",
        "Boolean" => "bool",
        "Object" => "object",
        _ => type.Name,
    };
    if (!type.IsGenericType)
    {
        return name;
    }

    string bare = name[..name.IndexOf('`')];
    return $"{bare}<{string.Join(", ", type.GetGenericArguments().Select(Name))}>";
}

square(12) = 144
Namaste, Asha
3 divides 12: True, today: Saturday
parse is a Func<string, int>; shout is an Action<string>
PLATFORM 4
status is a Func<bool, object>: 1, pending
isBlank is a Func<string, bool>: True

// A lambda with untyped parameters, assigned to var, gives the compiler nothing to infer a delegate type from.
var parse = s => int.Parse(s);

Console.WriteLine(parse("42"));

from session import run

# nonatural assigns a lambda whose parameter has no type to var. dotnet run builds the project first and stops at the
# error.
run("""
cd nonatural
!dotnet run
""")

$ cd nonatural
$ dotnet run
nonatural/Program.cs(2,13): error CS8917: The delegate type could not be inferred. [nonatural/App.csproj]

The build failed. Fix the build errors and run again.
[exit status 1]

// A lambda that uses a local variable of the method around it captures the variable itself, not a copy of its value.
int limit = 5;
Func<int, bool> isLow = units => units < limit;
Console.WriteLine($"limit {limit}: 4 units low? {isLow(4)}");

limit = 3;                                   // the lambda reads the variable when it runs, so it sees the change
Console.WriteLine($"limit {limit}: 4 units low? {isLow(4)}");

// A lambda can change a captured variable, and the method sees the change.
int alerts = 0;
Action<string> raise = sku =>
{
    alerts++;
    Console.WriteLine($"  alert {alerts}: {sku} is low");
};
raise("TEA-250");
raise("RICE-5");
Console.WriteLine($"alerts after two calls: {alerts}");

// Each call of MakeCounter makes a new variable, so each counter has its own.
Func<int> first = MakeCounter();
Func<int> second = MakeCounter();
Console.WriteLine($"first: {first()}, {first()}, {first()}; second: {second()}");

static Func<int> MakeCounter()
{
    int count = 0;
    return () => ++count;
}

limit 5: 4 units low? True
limit 3: 4 units low? False
  alert 1: TEA-250 is low
  alert 2: RICE-5 is low
alerts after two calls: 2
first: 1, 2, 3; second: 1

// Lambdas made inside loops. A for loop has one variable for all its passes; foreach has a new one in every pass.
var fromFor = new List<Func<int>>();
for (int i = 0; i < 3; i++)
{
    fromFor.Add(() => i);
}

Console.WriteLine($"for:            {string.Join(" ", fromFor.Select(f => f()))}");

var fromForeach = new List<Func<int>>();
foreach (int n in new[] { 0, 1, 2 })
{
    fromForeach.Add(() => n);
}

Console.WriteLine($"foreach:        {string.Join(" ", fromForeach.Select(f => f()))}");

// The fix for the for loop: copy the variable into a local declared inside the loop body.
var fixedFor = new List<Func<int>>();
for (int i = 0; i < 3; i++)
{
    int copy = i;
    fixedFor.Add(() => copy);
}

Console.WriteLine($"for with copy:  {string.Join(" ", fixedFor.Select(f => f()))}");

// The same bug with seats: every lambda reads the one variable, which ended at 4 after the loop.
string[] seats = ["B2-11", "B2-12", "B2-13", "B2-14"];
var announce = new List<Func<string>>();
for (int s = 0; s < seats.Length; s++)
{
    announce.Add(() => s < seats.Length ? seats[s] : $"no seat at index {s}");
}

Console.WriteLine($"seats from for: {string.Join(", ", announce.Select(a => a()))}");

for:            3 3 3
foreach:        0 1 2
for with copy:  0 1 2
seats from for: no seat at index 4, no seat at index 4, no seat at index 4, no seat at index 4

// Practice: write Counters.Start, Counters.From and Memo.Memoize, then run this file until all eight checks pass.
// What each method must do is in the comment above it. The fares are made up for this exercise.
(string Check, Func<string> Run, string Expected)[] checks =
[
    ("a counter counts from 1", () => Calls(Counters.Start(), 3), "1 2 3"),
    ("two counters are independent", TwoCounters, "1 2 3 | 1 2"),
    ("From starts where it is told", () => Calls(Counters.From(10), 3), "10 11 12"),
    ("a counter keeps counting between uses", KeepsCounting, "1 2, then 3"),
    ("Memoize returns the function's results", () => MemoFares(["Pune", "Nashik", "Pune"]).Results, "350 220 350"),
    ("Memoize calls the function once per input", () => MemoFares(["Pune", "Nashik", "Pune", "Pune"]).Lookups, "2 lookups"),
    ("two memoized functions keep separate results", SeparateMemos, "350 and 700"),
    ("a failed call is not remembered", FailureNotRemembered, "throws, then 220"),
];

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;

static string Calls(Func<int> counter, int times) =>
    string.Join(" ", Enumerable.Range(0, times).Select(_ => counter()));

static string TwoCounters()
{
    Func<int> a = Counters.Start();
    Func<int> b = Counters.Start();
    string first = Calls(a, 3);
    return $"{first} | {Calls(b, 2)}";
}

static string KeepsCounting()
{
    Func<int> c = Counters.Start();
    string first = Calls(c, 2);
    return $"{first}, then {c()}";
}

// A slow fare lookup that counts how often it really runs.
static (string Results, string Lookups) MemoFares(string[] cities)
{
    int lookups = 0;
    Func<string, int> fare = city =>
    {
        lookups++;
        return city == "Pune" ? 350 : 220;
    };
    Func<string, int> fast = Memo.Memoize(fare);
    string results = string.Join(" ", cities.Select(c => fast(c)));
    return (results, $"{lookups} lookups");
}

static string SeparateMemos()
{
    Func<string, int> sleeper = Memo.Memoize<string, int>(_ => 350);
    Func<string, int> ac = Memo.Memoize<string, int>(_ => 700);
    return $"{sleeper("Pune")} and {ac("Pune")}";
}

static string FailureNotRemembered()
{
    bool down = true;
    Func<string, int> fast = Memo.Memoize<string, int>(city => down ? throw new TimeoutException("fares service down") : 220);
    string first;
    try
    {
        first = fast("Nashik").ToString();
    }
    catch (TimeoutException)
    {
        first = "throws";
    }

    down = false;
    return $"{first}, then {fast("Nashik")}";
}

static class Counters
{
    // Returns a counter: each call returns the next number, 1, 2, 3 and so on. Every counter has its own count.
    public static Func<int> Start() => throw new NotImplementedException();

    // Returns a counter whose first call returns first, then first + 1, and so on.
    public static Func<int> From(int first) => throw new NotImplementedException();
}

static class Memo
{
    // Returns a function that gives the same results as f, but calls f only once for each input it has seen, and
    // remembers the result in a Dictionary<TIn, TOut> that only this function uses. When f throws, nothing is
    // remembered, so the next call with that input calls f again.
    public static Func<TIn, TOut> Memoize<TIn, TOut>(Func<TIn, TOut> f)
        where TIn : notnull => throw new NotImplementedException();
}

a counter counts from 1: FAIL, throws NotImplementedException instead of 1 2 3
two counters are independent: FAIL, throws NotImplementedException instead of 1 2 3 | 1 2
From starts where it is told: FAIL, throws NotImplementedException instead of 10 11 12
a counter keeps counting between uses: FAIL, throws NotImplementedException instead of 1 2, then 3
Memoize returns the function's results: FAIL, throws NotImplementedException instead of 350 220 350
Memoize calls the function once per input: FAIL, throws NotImplementedException instead of 2 lookups
two memoized functions keep separate results: FAIL, throws NotImplementedException instead of 350 and 700
a failed call is not remembered: FAIL, throws NotImplementedException instead of throws, then 220
0 of 8 checks pass