Prefer TypeScript inference over explicit types

- Remove explicit return types from functions where inference works
- Remove unnecessary variable type annotations (bigint, symbol)
- Add inference-first alternatives to explicit-return-types exercise
- Update README with guidance on when to use inference vs explicit types

Author: kentcdodds

exercises/01.primitive-types/04.solution.bigint-and-symbol/index.ts

@@ -1,15 +1,15 @@
 // BigInt and Symbol
 // Less common but important primitive types
 
-// BigInt for large integers
-const largeNumber: bigint = 9007199254740993n
-const anotherLarge: bigint = 1000000000000000000n
-const sum: bigint = largeNumber + anotherLarge
+// BigInt for large integers (TypeScript infers bigint from the n suffix)
+const largeNumber = 9007199254740993n
+const anotherLarge = 1000000000000000000n
+const sum = largeNumber + anotherLarge
 
-// Symbols are unique
-const userId: symbol = Symbol('user-id')
-const anotherId: symbol = Symbol('user-id')
-const areEqual: boolean = userId === anotherId // false!
+// Symbols are unique (TypeScript infers symbol from Symbol())
+const userId = Symbol('user-id')
+const anotherId = Symbol('user-id')
+const areEqual = userId === anotherId // false!
 
 console.log('Large number:', largeNumber)
 console.log('Another large:', anotherLarge)

exercises/04.functions/01.solution.parameters-and-returns/index.ts

@@ -1,15 +1,15 @@
 // E-commerce Utility Functions
 // Creating functions with typed parameters and returns
 
-function calculateTax(amount: number, rate: number): number {
+function calculateTax(amount: number, rate: number) {
 	return amount * rate
 }
 
-function formatPrice(cents: number): string {
+function formatPrice(cents: number) {
 	return `$${(cents / 100).toFixed(2)}`
 }
 
-function applyDiscount(price: number, discountPercent: number): number {
+function applyDiscount(price: number, discountPercent: number) {
 	return price - (price * discountPercent) / 100
 }
 

exercises/04.functions/03.solution.explicit-return-types/README.mdx

@@ -15,6 +15,21 @@ Even without seeing the implementation, you know exactly what each function
 expects and produces. This is invaluable in larger codebases where you might not
 have time to read every function body.
 
-In real projects, teams often have conventions about when to use explicit return
-types. A common approach: explicit for exported functions, inference for
-internal helpers.
+## When to use inference instead
+
+Many teams prefer letting TypeScript infer return types wherever possible:
+
+```ts
+function getFullName(firstName: string, lastName: string) {
+	return `${firstName} ${lastName}` // TypeScript infers: string
+}
+```
+
+This reduces redundancy since TypeScript already knows the return type from the
+implementation. Explicit return types are most valuable when:
+
+- The function is part of a public API boundary
+- You want to catch implementation mistakes early
+- The inferred type would be too wide (e.g., `string | number` when you want
+  just `string`)
+- State machine functions that must return valid states

exercises/04.functions/03.solution.explicit-return-types/index.ts

@@ -20,3 +20,16 @@ console.log(isValidEmail('test@example.com')) // true
 console.log(isValidEmail('invalid-email')) // false
 
 export { getFullName, parseAge, isValidEmail }
+
+// 🦉 Alternative: Inference-first approach
+// In practice, many developers prefer to let TypeScript infer return types.
+// This reduces redundancy since TypeScript can figure out the return type:
+//
+// function getFullName(firstName: string, lastName: string) {
+//   return `${firstName} ${lastName}`  // TypeScript infers: string
+// }
+//
+// Explicit return types are most valuable when:
+// - The function is exported as part of a public API
+// - You want to catch implementation mistakes early
+// - The inferred type would be too wide (e.g., string | number vs string)

exercises/04.functions/04.solution.arrow-functions/index.ts

@@ -2,20 +2,20 @@
 // Converting between function forms and using implicit returns
 
 // Arrow function with implicit return
-const double = (n: number): number => n * 2
+const double = (n: number) => n * 2
 
 // Arrow function with implicit return (template literal)
-const greet = (name: string): string => `Hello, ${name}!`
+const greet = (name: string) => `Hello, ${name}!`
 
 // Arrow function with explicit return (multiple lines)
-const calculateTotal = (prices: number[], taxRate: number): number => {
+const calculateTotal = (prices: number[], taxRate: number) => {
 	const subtotal = prices.reduce((sum, price) => sum + price, 0)
 	const tax = subtotal * taxRate
 	return subtotal + tax
 }
 
 // Arrow function with implicit return
-const isEven = (n: number): boolean => n % 2 === 0
+const isEven = (n: number) => n % 2 === 0
 
 // Function using arrow function callbacks
 function processNumbers(numbers: number[]) {