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
```

> 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.

```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.

> 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.
```

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.