Offering my switchCase Extension about dartx HOT 2 OPEN

// Original Proposal
_counter.switchCase({
      1: Text("It's one"),
      2: Text("It's two"),
      3: Text("It's three"),
    }) ??
    Text("Other number"),

// Original Proposal with default
_counter.switchCase(
  {
    1: Text("It's one"),
    2: Text("It's two"),
    3: Text("It's three"),
  },
  Text("Other number"),
),

// Original Proposal with functions
_counter.switchCase(
  {
    1: () => Text("It's one"),
    2: () => Text("It's two"),
    3: () => Text("It's three"),
  },
  () => Text("Other number"),
)(),

// Proposal 2 - forced functions
_counter.switchCase2({
      1: () => Text("It's one"),
      2: () => Text("It's two"),
      3: () => Text("It's three"),
    }) ??
    Text("Other number"),

// Proposal 2 with default
_counter.switchCase2(
  {
    1: () => Text("It's one"),
    2: () => Text("It's two"),
    3: () => Text("It's three"),
  },
  fallback: () => Text("Other number"),
),

// Proposal 3 - match or error
_counter.switchCase3({
  0: () => Text("zero"),
  1: () => Text("It's one"),
  2: () => Text("It's two"),
  3: () => Text("It's three"),
}).match(),

// Proposal 3 - no default, but null (dartfmt 😖)
_counter.switchCase3({
      1: () => Text("It's one"),
      2: () => Text("It's two"),
      3: () => Text("It's three"),
    }).matchOrNull() ??
    Text("Other number"),

// Proposal 3 with explicit default
_counter.switchCase3({
  1: () => Text("It's one"),
  2: () => Text("It's two"),
  3: () => Text("It's three"),
}).defaultTo(() => Text("Other number")),

extension switchInt on int {
  T switchCase<int, T>(Map<int, T> cases, [T defaultValue]) {
    if (cases.containsKey(this)) return cases[this];
    return defaultValue;
  }

  T switchCase2<int, T>(Map<int, T Function()> cases, {T Function() fallback}) {
    if (cases.containsKey(this)) return cases[this]();
    if (fallback == null) return null;
    return fallback();
  }

  SwitchCase<T> switchCase3<int, T>(Map<int, T Function()> cases) {
    if (cases.containsKey(this)) return SwitchCase.match(cases[this]());
    return SwitchCase.noMatch();
  }
}

class SwitchCase<T> {
  SwitchCase.match(this.value) : matched = true;
  SwitchCase.noMatch()
      : matched = false,
        value = null;

  final T value;
  final bool matched;

  T match() {
    if (matched) return value;
    throw "no default argument";
  }

  T matchOrNull() {
    if (matched) return value;
    return null;
  }

  T defaultTo(T Function() fallback) {
    if (!matched) return fallback();
    return value;
  }
}