Monad

using System;
using System.Linq;

// Parse an integer, returning Option because parsing can fail.
static Option<int> ParseInt(string s) =>
    int.TryParse(s, out var n) ? new Some<int>(n) : new None<int>();

// Halve even numbers only. This step can fail too.
static Option<int> Half(int n) =>
    n % 2 == 0 ? new Some<int>(n / 2) : new None<int>();

// Place a value in the context: return, also called unit.
static Option<int> Unit(int n) => new Some<int>(n);

Option<Option<int>> nested = ParseInt("8").Map(Half);
Console.WriteLine($"Map:  {nested}");
Console.WriteLine($"Bind: {ParseInt("8").Bind(Half)}");
Console.WriteLine($"Bind: {ParseInt("7").Bind(Half)}");
Console.WriteLine($"Bind: {ParseInt("x").Bind(Half)}");

// Check the three laws on sample values, rather than proving them.
int[] values = [8, 7];
Option<int>[] ms = [ParseInt("8"), ParseInt("6"), ParseInt("x")];
Console.WriteLine("left identity:  " + values.All(a => Unit(a).Bind(Half) == Half(a)));
Console.WriteLine("right identity: " + ms.All(m => m.Bind(Unit) == m));
Console.WriteLine("associativity:  " + ms.All(m =>
    m.Bind(Half).Bind(Half) == m.Bind(x => Half(x).Bind(Half))));

abstract record Option<T>;
sealed record Some<T>(T Value) : Option<T>
{
    public override string ToString() => $"Some({Value})";
}
sealed record None<T> : Option<T>
{
    public override string ToString() => "None";
}

static class OptionExtensions
{
    // Map applies f to a present value and wraps the result in Some.
    public static Option<U> Map<T, U>(this Option<T> option, Func<T, U> f) => option switch
    {
        Some<T>(var value) => new Some<U>(f(value)),
        _ => new None<U>(),
    };

    // Bind passes a present value to f and uses its returned Option directly.
    public static Option<U> Bind<T, U>(this Option<T> option, Func<T, Option<U>> f) => option switch
    {
        Some<T>(var value) => f(value),
        _ => new None<U>(),
    };
}

Map:  Some(Some(4))
Bind: Some(4)
Bind: None
Bind: None
left identity:  True
right identity: True
associativity:  True

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

var users = new Dictionary<int, User>
{
    [1] = new("Alice", "core"),
    [2] = new("Bob", null),
    [3] = new("Dave", "ops"),
};
var teams = new Dictionary<string, Team>
{
    ["core"] = new("Core", "carol"),
    ["ops"] = new("Ops", "erin"),
};
// erin has no registered email address.
var emails = new Dictionary<string, string> { ["carol"] = "carol@example.com" };

Option<User> FindUser(int id) =>
    users.TryGetValue(id, out var user) ? new Some<User>(user) : new None<User>();
Option<Team> FindTeam(User user) =>
    user.TeamId is string teamId && teams.TryGetValue(teamId, out var team)
        ? new Some<Team>(team) : new None<Team>();
Option<string> FindEmail(Team team) =>
    emails.TryGetValue(team.ManagerId, out var email) ? new Some<string>(email) : new None<string>();

// 1. Nested if statements add another indentation level for each lookup.
Option<string> WithIfs(int id)
{
    if (users.TryGetValue(id, out var user))
    {
        if (user.TeamId is string teamId && teams.TryGetValue(teamId, out var team))
        {
            if (emails.TryGetValue(team.ManagerId, out var email))
            {
                return new Some<string>($"{user.Name} -> {email}");
            }
        }
    }
    return new None<string>();
}

// 2. Direct Bind calls nest lambdas to keep user available at the end.
Option<string> WithBind(int id) =>
    FindUser(id).Bind(user =>
        FindTeam(user).Bind(team =>
            FindEmail(team).Map(email => $"{user.Name} -> {email}")));

// 3. The compiler translates the query from clauses into SelectMany calls.
Option<string> WithQuery(int id) =>
    from user in FindUser(id)
    from team in FindTeam(user)
    from email in FindEmail(team)
    select $"{user.Name} -> {email}";

foreach (var id in new[] { 1, 2, 3, 99 })
{
    var a = WithIfs(id);
    var b = WithBind(id);
    var c = WithQuery(id);
    Console.WriteLine($"id {id}: {c}, all three equal: {a == b && b == c}");
}

// SelectMany on IEnumerable<T> uses the same syntax, joining the sequences from each element.
var pairs =
    from team in new[] { "Core", "Ops" }
    from role in new[] { "dev", "qa" }
    select $"{team}/{role}";
Console.WriteLine(string.Join(", ", pairs));

record User(string Name, string? TeamId);
record Team(string Name, string ManagerId);

abstract record Option<T>;
sealed record Some<T>(T Value) : Option<T>
{
    public override string ToString() => $"Some({Value})";
}
sealed record None<T> : Option<T>
{
    public override string ToString() => "None";
}

static class OptionExtensions
{
    public static Option<U> Map<T, U>(this Option<T> option, Func<T, U> f) => option switch
    {
        Some<T>(var value) => new Some<U>(f(value)),
        _ => new None<U>(),
    };

    public static Option<U> Bind<T, U>(this Option<T> option, Func<T, Option<U>> f) => option switch
    {
        Some<T>(var value) => f(value),
        _ => new None<U>(),
    };

    // A single from ... select query is translated to this Select method.
    public static Option<U> Select<T, U>(this Option<T> option, Func<T, U> f) => option.Map(f);

    // A second from clause uses this overload: Bind, then apply the result selector.
    public static Option<V> SelectMany<T, U, V>(
        this Option<T> option, Func<T, Option<U>> f, Func<T, U, V> resultSelector) =>
        option.Bind(t => f(t).Map(u => resultSelector(t, u)));
}

id 1: Some(Alice -> carol@example.com), all three equal: True
id 2: None, all three equal: True
id 3: None, all three equal: True
id 99: None, all three equal: True
Core/dev, Core/qa, Ops/dev, Ops/qa

type Option<T> = { kind: "some"; value: T } | { kind: "none" };
const some = <T>(value: T): Option<T> => ({ kind: "some", value });
const none: Option<never> = { kind: "none" };
const show = <T>(o: Option<T>): string => (o.kind === "some" ? `Some(${o.value})` : "None");

// Pass a present value to f and use its returned Option directly.
function bind<T, U>(o: Option<T>, f: (value: T) => Option<U>): Option<U> {
  return o.kind === "some" ? f(o.value) : none;
}

type User = { name: string; teamId: string | null };
type Team = { name: string; managerId: string };
const users = new Map<number, User>([
  [1, { name: "Alice", teamId: "core" }],
  [2, { name: "Bob", teamId: null }],
  [3, { name: "Dave", teamId: "ops" }],
]);
const teams = new Map<string, Team>([
  ["core", { name: "Core", managerId: "carol" }],
  ["ops", { name: "Ops", managerId: "erin" }],
]);
// erin has no registered email address.
const emails = new Map<string, string>([["carol", "carol@example.com"]]);

const fromMap = <K, V>(map: Map<K, V>, key: K): Option<V> =>
  map.has(key) ? some(map.get(key) as V) : none;
const findUser = (id: number): Option<User> => fromMap(users, id);
const findTeam = (user: User): Option<Team> =>
  user.teamId === null ? none : fromMap(teams, user.teamId);
const findEmail = (team: Team): Option<string> => fromMap(emails, team.managerId);

for (const id of [1, 2, 3, 99]) {
  const result = bind(findUser(id), (user) =>
    bind(findTeam(user), (team) =>
      bind(findEmail(team), (email) => some(`${user.name} -> ${email}`))));
  console.log(`id ${id}: ${show(result)}`);
}

// For arrays, map nests the results; flatMap joins them into one layer.
const nested = ["Core", "Ops"].map((team) => ["dev", "qa"].map((role) => `${team}/${role}`));
const flat = ["Core", "Ops"].flatMap((team) => ["dev", "qa"].map((role) => `${team}/${role}`));
console.log(JSON.stringify(nested));
console.log(JSON.stringify(flat));

id 1: Some(Alice -> carol@example.com)
id 2: None
id 3: None
id 99: None
[["Core/dev","Core/qa"],["Ops/dev","Ops/qa"]]
["Core/dev","Core/qa","Ops/dev","Ops/qa"]