1// Before: Manual type annotations required
2const userPreferences = {
3 theme: 'dark' as const,
4 language: 'en' as const,
5 notifications: true
6};
7 
8// After: TypeScript 5.6 infers correctly!
9const userPreferences = {
10 theme: 'dark',
11 language: 'en', 
12 notifications: true
13} as const; // Much cleaner!
14 
15// Even better with functions
16function createConfig<T>(config: T) {
17 return {
18 ...config,
19 timestamp: Date.now(),
20 version: '1.0.0'
21 };
22}
23 
24// TypeScript now preserves exact types
25const myConfig = createConfig({
26 apiUrl: 'https://api.example.com',
27 retries: 3,
28 timeout: 5000
29});
30// myConfig.apiUrl is exactly 'https://api.example.com', not string!

1// Old error message:
2// "Type 'string' is not assignable to type 'number'"
3 
4// New detailed error in 5.6:
5// "Cannot assign 'string' to 'number'
6// Did you mean to use parseInt() or parseFloat()?"
7 
8interface User {
9 id: number;
10 name: string;
11 email: string;
12}
13 
14function updateUser(user: User, updates: Partial<User>) {
15 return { ...user, ...updates };
16}
17 
18// Better error with suggestions
19updateUser({ id: 1, name: "John" }, { id: "2" });
20// ^^^
21// Error: Type 'string' is not assignable to type 'number | undefined'
22// Suggestion: Convert to number with Number() or parseInt()

1// Problem: TypeScript infers from all arguments
2function merge<T>(obj1: T, obj2: T): T {
3 return { ...obj1, ...obj2 };
4}
5 
6// This fails because TypeScript can't decide the type
7merge({ name: "John" }, { age: 30 }); // Error!
8 
9// Solution: Use NoInfer<T>
10function mergeFixed<T>(obj1: T, obj2: NoInfer<T>): T {
11 return { ...obj1, ...obj2 };
12}
13 
14// Now TypeScript uses only the first argument for inference
15const result = mergeFixed({ name: "John" }, { name: "Jane" }); // Works!

1// Large type computations are now optimized
2type DeepReadonly<T> = {
3 readonly [P in keyof T]: T[P] extends object 
4 ? DeepReadonly<T[P]> 
5 : T[P];
6};
7 
8// Complex mapped types compile 30% faster
9type APIResponse<T> = {
10 data: T;
11 status: 'success' | 'error';
12 timestamp: number;
13 pagination?: {
14 page: number;
15 limit: number;
16 total: number;
17 };
18};

1// Define event map
2interface EventMap {
3 'user:login': { userId: string; timestamp: number };
4 'user:logout': { userId: string; reason: string };
5 'page:view': { path: string; referrer?: string };
6}
7 
8// Type-safe event emitter
9class TypedEventEmitter {
10 emit<K extends keyof EventMap>(
11 event: K, 
12 data: EventMap[K]
13 ): void {
14 // Implementation here
15 console.log(`Event: ${event}`, data);
16 }
17 
18 on<K extends keyof EventMap>(
19 event: K,
20 handler: (data: EventMap[K]) => void
21 ): void {
22 // Implementation here
23 }
24}
25 
26// Usage with perfect autocomplete and type safety
27const emitter = new TypedEventEmitter();
28 
29emitter.emit('user:login', { 
30 userId: '123', 
31 timestamp: Date.now() 
32}); // ✅ Perfectly typed
33 
34emitter.emit('user:login', { 
35 userId: 123 // ❌ TypeScript error: number not assignable to string
36});

1// Temporary migration helper
2function legacyFunction(data: any) {
3 // @ts-expect-error - TODO: Add proper types in v2
4 return processLegacyData(data);
5}

1interface FormSchema {
2 [key: string]: {
3 type: 'string' | 'number' | 'boolean';
4 required?: boolean;
5 default?: any;
6 };
7}
8 
9// Challenge: Make this fully type-safe
10function createForm<T extends FormSchema>(schema: T) {
11 // Return type should infer from schema
12 // Hint: Use mapped types and conditional types
13}