ts-02-groupby

# Generic `groupBy`

Implement **`solution.ts`** exporting a generic function:

```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]>
```

Group the `items` into a record keyed by the result of `keyFn(item)`. Each value is
the array of items that produced that key, **in their original order**.

- `groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? "even" : "odd"))`
  → `{ odd: [1, 3], even: [2, 4] }`
- `groupBy([], (n: number) => n)` → `{}`
- A numeric key works too:
  `groupBy(["a", "bb", "ccc", "dd"], (s) => s.length)`
  → `{ 1: ["a"], 2: ["bb", "dd"], 3: ["ccc"] }`

Keep it fully typed (must pass `tsc --noEmit` in strict mode). Do not use `any` in the
public API.

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { groupBy } from "./solution.ts";

test("groups by string key, preserving order", () => {
  const r = groupBy([1, 2, 3, 4, 5], (n) => (n % 2 === 0 ? "even" : "odd"));
  assert.deepEqual(r, { odd: [1, 3, 5], even: [2, 4] });
});

test("empty input yields empty record", () => {
  assert.deepEqual(groupBy<number, number>([], (n) => n), {});
});

test("groups by numeric key", () => {
  const r = groupBy(["a", "bb", "ccc", "dd"], (s) => s.length);
  assert.deepEqual(r, { 1: ["a"], 2: ["bb", "dd"], 3: ["ccc"] });
});

test("groups objects by a property", () => {
  const people = [
    { name: "Ana", city: "NYC" },
    { name: "Bo", city: "LA" },
    { name: "Cy", city: "NYC" },
  ];
  const r = groupBy(people, (p) => p.city);
  assert.deepEqual(r, {
    NYC: [
      { name: "Ana", city: "NYC" },
      { name: "Cy", city: "NYC" },
    ],
    LA: [{ name: "Bo", city: "LA" }],
  });
});

test("single group when keyFn is constant", () => {
  const r = groupBy([1, 2, 3], () => "all");
  assert.deepEqual(r, { all: [1, 2, 3] });
});

test("does not mutate the input array", () => {
  const input = [3, 1, 2];
  groupBy(input, (n) => n);
  assert.deepEqual(input, [3, 1, 2]);
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  const result = {} as Record<K, T[]>;
  for (const item of items) {
    const key = keyFn(item);
    if (!(key in result)) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
```

The user wants a generic `groupBy` function in TypeScript.
The function signature is:
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]>
```

I need to implement this function.
It should group items by the key returned by `keyFn`.
The order of items within each group should be preserved.
It should handle empty arrays correctly.
It should work with both string and numeric keys.
It must be fully typed and pass `tsc --noEmit` in strict mode.
No `any` in the public API.

Implementation details:
I can use `reduce` or a simple loop.
Since `Record<K, T[]>` expects keys of type `K`, and `K` extends `string | number`, I can initialize an empty object and push items to arrays.
TypeScript might complain about indexing with `K` if not handled carefully, but `Record<K, T[]>` is fine.
Actually, `Record<K, T[]>` means the return type is an object with keys of type `K` and values of type `T[]`.
When building it, I can use `const result = {} as Record<K, T[]>;` or just `const result: Record<K, T[]> = {} as Record<K, T[]>;` but that's a bit hacky.
Alternatively, I can use `Map` but the return type is `Record<K, T[]>`.
I'll stick to an object.

Let's write it out:
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  const result = {} as Record<K, T[]>;
  for (const item of items) {
    const key = keyFn(item);
    if (!result[key]) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
```

Wait, `result[key]` might cause a type error if `result` is typed as `Record<K, T[]>` because `K` could be `string | number`, and indexing with `K` on `Record<K, T[]>` is fine, but TypeScript might complain about `!result[key]` because `result[key]` could be `undefined` initially if we don't assert or use `as`.
Actually, `Record<K, T[]>` means all keys of type `K` are present and have type `T[]`. But initially the object is empty. So `result[key]` will be `undefined` at first.
To avoid type errors, I can do:
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  const result = {} as Record<K, T[]>;
  for (const item of items) {
    const key = keyFn(item);
    if (!(key in result)) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
```
Using `key in result` is safer and avoids `undefined` type issues. Or I can just use `if (!result[key])` but with `as Record<K, T[]>`, `result[key]` is `T[]`, so `!result[key]` checks if it's falsy. Since arrays are truthy, it works. But TypeScript might complain about `result[key]` being possibly undefined if we don't use `as`. Actually, `result` is typed as `Record<K, T[]>`, so `result[key]` is `T[]`. `!result[key]` is fine.

Wait, `Record<K, T[]>` with `K extends string | number` might cause issues if `K` is a union like `"even" | "odd"`. `Record<"even" | "odd", T[]>` is `{ even: T[]; odd: T[] }`. But we only want to create keys that actually appear. The return type `Record<K, T[]>` in the signature implies that all possible keys of type `K` will be present, but in practice, `groupBy` only creates keys for items that exist. This is a common TypeScript limitation. The signature given by the user is fixed: `Record<K, T[]>`. I'll stick to it.

Actually, to be strictly correct with TypeScript, `Record<K, T[]>` means every key in `K` must exist. But `groupBy` typically returns a partial record. However, the prompt explicitly gives the signature:
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]>
```
So I must match it exactly. I'll use `as Record<K, T[]>` for the accumulator.

Let's test mentally:
```ts
const result = {} as Record<K, T[]>;
for (const item of items) {
  const key = keyFn(item);
  if (!result[key]) {
    result[key] = [];
  }
  result[key].push(item);
}
return result;
```
This is standard and works.

Wait, `K extends string | number`. If `K` is `number`, `Record<number, T[]>` is `{ [key: number]: T[] }`. That's fine.
One minor thing: `!result[key]` might trigger a strict null checks warning if `result[key]` is considered possibly undefined, but since `result` is `Record<K, T[]>`, `result[key]` is `T[]`, which is never undefined. So `!result[key]` is fine.

Alternatively, I can use `reduce`:
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  return items.reduce((acc, item) => {
    const key = keyFn(item);
    if (!acc[key]) acc[key] = [];
    acc[key].push(item);
    return acc;
  }, {} as Record<K, T[]>);
}
```
This is concise and idiomatic.

Let's verify types.
`acc` is `Record<K, T[]>`.
`acc[key]` is `T[]`.
`!acc[key]` checks if array is empty? Wait! `!acc[key]` will be false if `acc[key]` is an empty array `[]`, because `[]` is truthy. So `if (!acc[key])` will never be true after the first push. That's correct.
But initially, `acc` is `{}` cast to `Record<K, T[]>`. So `acc[key]` is technically `T[]` according to types, but at runtime it's `undefined`. The cast hides this. `!acc[key]` will be true when `acc[key]` is `undefined`. This works at runtime. TypeScript won't complain because of the cast.

To be safer and avoid the cast if possible, I could use `Partial<Record<K, T[]>>` for the accumulator, but the return type must be `Record<K, T[]>`. I'll stick with the cast, it's standard for this kind of function.

Actually, a better way without `as` for the accumulator:
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  const result: Record<K, T[]> = {} as Record<K, T[]>;
  for (const item of items) {
    const key = keyFn(item);
    if (!(key in result)) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
```
`key in result` is safe and doesn't rely on truthiness of arrays.

Wait, `Record<K, T[]>` with `K extends string | number` might cause an issue if `K` is a specific literal type like `"even" | "odd"`. `Record<"even" |
…[10326 chars elided]…
eck: `groupBy([], (n: number) => n)` returns `{}`. Type is `Record<number, number[]>`. At runtime `{}`. This matches.

Everything looks solid.
Output matches request.
Proceeds. 
[Final Check of the Prompt]
"Implement **`solution.ts`** exporting a generic function:"
Signature matches.
Examples match.
"Keep it fully typed (must pass `tsc --noEmit` in strict mode). Do not use `any` in the public API."
Checked.
All good.
Output generation. 
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  const result = {} as Record<K, T[]>;
  for (const item of items) {
    const key = keyFn(item);
    if (!(key in result)) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
```
Done. 
(Self-Correction/Note during thought)
Actually, `key in result` might trigger a type error in some TS versions if `result` is typed as `Record<K, T[]>` but initialized as `{}`, because `{}` doesn't have keys of type `K`. However, `as Record<K, T[]>` tells TS it has those keys. The `in` operator is safe. Alternatively, `if (!result[key])` is more common and works fine because TS ignores the runtime `undefined` due to the cast. I'll stick with `if (!(key in result))` as it's cleaner. Actually, `if (!result[key])` is fine too. I'll use `if (!result[key])` for brevity, it's standard. Wait, `!result[key]` might be flagged by `strictNullChecks` if `result[key]` is `T[]` (always truthy). So `!(key in result)` is definitely safer. I'll keep it.

Final decision: use `if (!(key in result))`.
Code is ready.
Output matches.
Proceeds. 
[Output Generation] (matches the final code block)
```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  const result = {} as Record<K, T[]>;
  for (const item of items) {
    const key = keyFn(item);
    if (!(key in result)) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
```
All good. 
Done. 
[Output Generation] -> *Proceeds*