interface Chain<T> {
  // normal
  filter(cb: Predicate<T>) : Chain<T>;
  // manual limit result to sub type
  filter<U extends T>(cb: Predicate<T>): Chain<U>;
  // explicit type protection to sub type
  filter<U extends T>(cb: TypeProtection<T, U>): Chain<U>;
}

function uncapitalize<S extends string>(s: S): Uncapitalize<S> {
  // ...
}
const obj = { "gEt": 1, "PoSt": 2, "puT": 3 };

const uncapitalized = Object.fromEntries(
  Object.entries(obj)
    .map(p => [uncapitalize(p[0]), p[1]])
);

const elegant = obj
  .toPairs()
  .map(([key, value]) => [uncapitalize(key), value] as const)
  // key is "gEt" | "poSt" | "puT" now
  .toDictionary(p => p[0], p => p[1]);

import "@lovekicher/iterable-chain/global";

import { chain } from "@lovekicher/iterable-chain";

const numbers = [1, 2, 3, 4, 5];

// From helper methods
const chain1 = numbers.chain();

// Or directly
const chain2 = chain(numbers);

const chain = [
    [2018, 99],
    [2019, 327],
    [2020, 404],
    [2021, 653],
    [2022, 202],
  ]
  .chain()
  .orderBy(x => x[1], true)
  .map(x => x[1])
  .filter(x => x % 2 == 0)
  .map(x => "0x" + x.toString(16));
// All callback functions have not been called

const result = chain.toArray();
// `toArray` is a collect method, now get ["0x194", "0xca"]

const dict = [
    { owner: "foo", count: 3 },
    { owner: "bar", count: 10 },
    { owner: "baz", count: 16 },
  ]
  .chain()
  .toDictionary(x => x.owner, x => x.count);
/* {
  "foo": 3,
  "bar": 10,
  "baz": 16
} */