Errata

This may be nitpicky, but the type of a value returned from `objectToCamel` is not accurate when it is called with an object with `number` keys:

```ts
const camel = objectToCamel({foo_bar: 12, 1: 'a'});
// camel's value at runtime is {fooBar: 12, 1: 'a'},
// while its type here is {fooBar: 12}
```

The accurate definition of `ObjectToCamel` should be:

```ts
type ObjectToCamel<T extends object> = {
[K in keyof T as K extends string
? ToCamel<K> : K extends number
? K : never]: T[K]
};
```

Here's the full example code to see the issue (I tried to provide a link to TS Playground but this form doesn't allow me to do so...):

```ts
type ToCamel<S extends string> =
S extends `${infer Head}_${infer Tail}`
? `${Head}${Capitalize<ToCamel<Tail>>}`
: S;

type ObjectToCamel<T extends object> = {
[K in keyof T as ToCamel<K & string>]: T[K]
};
function camelCase(term: string) {
return term.replace(/_([a-z])/g, m => m[1].toUpperCase());
}
function objectToCamel<T extends object>(obj: T): ObjectToCamel<T> {
const out: any = {};
for (const [k, v] of Object.entries(obj)) {
out[camelCase(k)] = v;
}
return out;
}

const camel = objectToCamel({ foo_bar: 12, 1: 'a' });
// camel's value at runtime is {fooBar: 12, 1: 'a'},
// while its type here is {fooBar: 12}
console.log(camel.fooBar); // 12
console.log(camel[1]); // this should not raise an error

type ObjectToCamelImproved<T extends object> = {
[K in keyof T as K extends string
? ToCamel<K> : K extends number
? K : never]: T[K]
};

const camel2 = (objectToCamel as <T extends object>(obj: T) => ObjectToCamelImproved<T>)({ foo_bar: 12, 1: 'a' });
console.log(camel2.fooBar); // 12
console.log(camel2[1]); // a
```

Note from the Author or Editor:
This is definitely nitpicky :)

This is so in the weeds and the workaround is so cumbersome (double conditional) that I wouldn't want to add anything more than a caveat like "making this work with numeric index types is left as an exercise to the reader."

Note that Kenji's version, which explicitly checks for `number`, is better than `K in keyof T as K extends string ? ToCamel<K> : K` since that would allow Symbol keys to pass through, whereas at runtime the `objectToCamel` drops these (since `Object.entries` does).

> Adding this special case does not change the behavior of PartiallyPartial at all

This is not correct. Because the condition of the version of PartiallyPartial on page 250 is not distributed over unions, it behaves differently than that on page 251 when `T` is a union type:

```ts
type Resolve<T> = T extends Function ? T : { [K in keyof T]: T[K] };
type PartiallyPartialP250<T, K extends keyof T> =
Resolve<Partial<Pick<T, K>> & Omit<T, K>>;
type PartiallyPartialP251<T extends object, K extends keyof T> =
[K] extends [never]
? T // special case
: T extends unknown // extra conditional to preserve distribution over unions
? Resolve<Partial<Pick<T, K>> & Omit<T, K>>
: never;
interface BlogComment {
commentId: number;
title: string;
content: string;
}
interface VlogComment {
commentId: number;
time: number;
content: string;
}
type PartCommentP250 = PartiallyPartialP250<BlogComment | VlogComment, 'content'>;
// ^? type PartCommentP250 = {
// content?: string | undefined;
// commentId: number;
// }
type PartCommentP251 = PartiallyPartialP251<BlogComment | VlogComment, 'content'>;
// ^? type PartCommentP251 = {
// content?: string | undefined;
// commentId: number;
// title: string;
// } | {
// content?: string | undefined;
// commentId: number;
// time: number;
// }
```

The `T extends unknown` part must either be removed from the page 251 version or added to the page 250 version to make the description correct.

Note from the Author or Editor:
The text is technically correct in that "Adding this special case" on its own does not change the behavior of `PartiallyPartial`.

Distributing over unions _is_ a behavior change but it's brought about by the other change (adding the `T extends unknown ? ...` clause). This is an unrelated but still desirable change.

The only part I find objectionable is the comment:

```ts
: T extends unknown // extra conditional to preserve distribution over unions
```

The word "preserve" suggests that this was the old behavior, which it was not. The comment should be changed to:

```ts
: T extends unknown // extra conditional to distribute over unions
```

```ts
function buildURL<Path extends keyof RouteQueryParams>( route: Path,
...args: (
RouteQueryParams[Path] extends null ? []
: [params: RouteQueryParams[Path]]
) ){
const params = args ? args[0] : null;
return route + (params ? `?${new URLSearchParams(params)}` : ''); }
```

The use of the ternary operator is unnecessary because `args` is non-null.

Note from the Author or Editor:
Correct, the ternary can be removed because `args` will always be an array, and in JS a zero-length array is still truthy.

- const params = args ? args[0] : null;
+ const params = args[0];

> Typically it’s string or a subtype of string such as a union of string literals.

A string literal or a union of string literals cannot be used for a type for the key in index signatures.

```ts
type Rocket = {[property: 'foo' | 'bar']: string};
```

The above code results in the following error:

```
An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead.
```

Note from the Author or Editor:
It can be a template literal type, which can be a proper subtype of string, but it can't be a string literal type or union thereof. The bullet point should mention template literal types.

Although the sentence above the code snippet says, "Here’s the equivalent with Lodash:" it's not equivalent to the previous code snippet because of `.slice(0, 10)` at last.

Note from the Author or Editor:
The `.slice(0, 10)` line should be dropped from the second example.