1function transferMoney(amount: number, from: string, to: string) {
2  // Transfer logic
3}
4
5// These are all valid TypeScript, but semantically wrong:
6transferMoney(accountId, amount, customerId);  // Arguments swapped
7transferMoney(-100, "acc1", "acc2");          // Negative amount
8transferMoney(0.001, "acc1", "acc2");         // Sub-cent amount
9

1// Brand pattern using intersection types
2type Brand<K, T> = K & { __brand: T };
3
4// Domain types
5type AccountId = Brand<string, 'AccountId'>;
6type CustomerId = Brand<string, 'CustomerId'>;
7type OrderId = Brand<string, 'OrderId'>;
8type USD = Brand<number, 'USD'>;
9type Shares = Brand<number, 'Shares'>;
10
11// Constructor functions that validate
12function AccountId(value: string): AccountId {
13  if (!/^ACC\d{10}$/.test(value)) {
14    throw new Error(`Invalid account ID: ${value}`);
15  }
16  return value as AccountId;
17}
18
19function USD(value: number): USD {
20  if (value < 0) {
21    throw new Error(`Amount cannot be negative: ${value}`);
22  }
23  if (!Number.isFinite(value)) {
24    throw new Error(`Amount must be finite: ${value}`);
25  }
26  // Ensure cent precision
27  const cents = Math.round(value * 100);
28  return (cents / 100) as USD;
29}
30
31// Now this fails at compile time!
32function transferMoney(amount: USD, from: AccountId, to: AccountId) {
33  // Implementation
34}
35
36const acc1 = AccountId("ACC0000000001");
37const acc2 = AccountId("ACC0000000002");
38const amount = USD(100.50);
39
40transferMoney(amount, acc1, acc2);  // ✓ Correct
41transferMoney(acc1, amount, acc2);  // ✗ Compile error!
42

1type Percentage = Brand<number, 'Percentage'>;
2type BasisPoints = Brand<number, 'BasisPoints'>;
3type Price = Brand<number, 'Price'>;
4type Quantity = Brand<number, 'Quantity'>;
5
6function Percentage(value: number): Percentage {
7  if (value < 0 || value > 100) {
8    throw new Error(`Percentage must be between 0 and 100: ${value}`);
9  }
10  return value as Percentage;
11}
12
13function BasisPoints(value: number): BasisPoints {
14  if (value < 0 || value > 10000) {
15    throw new Error(`Basis points must be between 0 and 10000: ${value}`);
16  }
17  return value as BasisPoints;
18}
19
20// Utility conversions
21function percentageToBasisPoints(pct: Percentage): BasisPoints {
22  return BasisPoints(pct * 100);
23}
24
25function basisPointsToPercentage(bp: BasisPoints): Percentage {
26  return Percentage(bp / 100);
27}
28
29// Type-safe calculations
30function calculateFee(amount: USD, rate: BasisPoints): USD {
31  const rateDecimal = rate / 10000;
32  return USD(amount * rateDecimal);
33}
34
35// This won't compile - can't mix Percentage and BasisPoints
36// const fee = calculateFee(USD(1000), Percentage(1.5));  // ✗ Error!
37

1type OrderStatus = 
2  | { status: 'pending'; submittedAt: Date }
3  | { status: 'accepted'; acceptedAt: Date; orderId: OrderId }
4  | { status: 'filled'; filledAt: Date; orderId: OrderId; fillPrice: Price }
5  | { status: 'rejected'; rejectedAt: Date; reason: string }
6  | { status: 'cancelled'; cancelledAt: Date; orderId: OrderId };
7
8interface Order {
9  id: OrderId;
10  accountId: AccountId;
11  symbol: string;
12  quantity: Shares;
13  orderType: 'market' | 'limit';
14  limitPrice?: Price;
15  orderStatus: OrderStatus;
16}
17
18// Type-safe state transitions
19function fillOrder(order: Order, fillPrice: Price): Order | Error {
20  // Only accepted orders can be filled
21  if (order.orderStatus.status !== 'accepted') {
22    return new Error(`Cannot fill order in ${order.orderStatus.status} status`);
23  }
24  
25  return {
26    ...order,
27    orderStatus: {
28      status: 'filled',
29      filledAt: new Date(),
30      orderId: order.orderStatus.orderId,  // TypeScript knows this exists!
31      fillPrice,
32    },
33  };
34}
35
36// The compiler enforces valid state transitions
37function getOrderId(order: Order): OrderId | null {
38  const { orderStatus } = order;
39  
40  switch (orderStatus.status) {
41    case 'pending':
42    case 'rejected':
43      return null;  // These states don't have orderId
44    case 'accepted':
45    case 'filled':
46    case 'cancelled':
47      return orderStatus.orderId;  // TypeScript knows these do!
48    default:
49      // Exhaustiveness check - compiler ensures we handled all cases
50      const _exhaustive: never = orderStatus;
51      return _exhaustive;
52  }
53}
54

1// Define valid currencies
2type Currency = 'USD' | 'EUR' | 'GBP' | 'JPY' | 'CHF';
3
4// Create all valid currency pairs at compile time
5type CurrencyPair = `${Currency}/${Currency}`;
6
7// This creates: "USD/EUR" | "USD/GBP" | "USD/JPY" | ... (all combinations)
8
9type ForexRate = {
10  pair: CurrencyPair;
11  bid: Price;
12  ask: Price;
13  timestamp: Date;
14};
15
16// Type-safe forex conversion
17function convertCurrency(
18  amount: USD,
19  rate: ForexRate,
20  toCurrency: Currency
21): number {
22  // Compile-time guarantee that rate.pair is a valid currency pair
23  const [from, to] = rate.pair.split('/') as [Currency, Currency];
24  
25  if (from !== 'USD' || to !== toCurrency) {
26    throw new Error(`Invalid rate for conversion`);
27  }
28  
29  return amount * rate.bid;
30}
31

1// Deep readonly utility type
2type DeepReadonly<T> = {
3  readonly [P in keyof T]: T[P] extends object 
4    ? DeepReadonly<T[P]> 
5    : T[P];
6};
7
8// Position type
9type Position = DeepReadonly<{
10  accountId: AccountId;
11  symbol: string;
12  quantity: Shares;
13  averagePrice: Price;
14  currentPrice: Price;
15  unrealizedPnL: USD;
16  lastUpdated: Date;
17}>;
18
19// Update functions return new objects
20function updatePosition(
21  position: Position,
22  newPrice: Price
23): Position {
24  const unrealizedPnL = USD(
25    (newPrice - position.averagePrice) * position.quantity
26  );
27  
28  return {
29    ...position,
30    currentPrice: newPrice,
31    unrealizedPnL,
32    lastUpdated: new Date(),
33  };
34}
35
36// This won't compile:
37// position.currentPrice = newPrice;  // ✗ Error: readonly property
38

1class Money {
2  private readonly _amount: number;
3  private readonly _currency: Currency;
4  
5  private constructor(amount: number, currency: Currency) {
6    this._amount = amount;
7    this._currency = currency;
8  }
9  
10  static USD(amount: number): Money {
11    return new Money(this.roundToCents(amount), 'USD');
12  }
13  
14  static EUR(amount: number): Money {
15    return new Money(this.roundToCents(amount), 'EUR');
16  }
17  
18  private static roundToCents(amount: number): number {
19    return Math.round(amount * 100) / 100;
20  }
21  
22  get amount(): number {
23    return this._amount;
24  }
25  
26  get currency(): Currency {
27    return this._currency;
28  }
29  
30  add(other: Money): Money {
31    if (this._currency !== other._currency) {
32      throw new Error(`Cannot add ${this._currency} and ${other._currency}`);
33    }
34    return new Money(this._amount + other._amount, this._currency);
35  }
36  
37  multiply(factor: number): Money {
38    return new Money(this._amount * factor, this._currency);
39  }
40  
41  isZero(): boolean {
42    return this._amount === 0;
43  }
44  
45  isPositive(): boolean {
46    return this._amount > 0;
47  }
48  
49  toString(): string {
50    return `${this._amount.toFixed(2)} ${this._currency}`;
51  }
52}
53
54// Usage
55const price = Money.USD(99.99);
56const fee = Money.USD(1.50);
57const total = price.add(fee);  // Money { 101.49 USD }
58
59// This won't compile - different types!
60// const mixed = Money.USD(100).add(Money.EUR(100));  // ✗ Runtime error
61

1import { z } from 'zod';
2
3// Define schema with runtime validation
4const OrderSchema = z.object({
5  accountId: z.string().regex(/^ACC\d{10}$/),
6  symbol: z.string().regex(/^[A-Z]{1,5}$/),
7  quantity: z.number().positive().int(),
8  orderType: z.enum(['market', 'limit']),
9  limitPrice: z.number().positive().optional(),
10  side: z.enum(['buy', 'sell']),
11}).refine(
12  (data) => data.orderType !== 'limit' || data.limitPrice !== undefined,
13  { message: "Limit orders must have a limit price" }
14);
15
16// Infer TypeScript type from schema
17type OrderInput = z.infer<typeof OrderSchema>;
18
19// Type-safe parsing with runtime validation
20function submitOrder(input: unknown): Order | Error {
21  const result = OrderSchema.safeParse(input);
22  
23  if (!result.success) {
24    return new Error(result.error.message);
25  }
26  
27  const data = result.data;  // Fully typed!
28  
29  return {
30    id: OrderId(generateOrderId()),
31    accountId: AccountId(data.accountId),
32    symbol: data.symbol,
33    quantity: Shares(data.quantity),
34    orderType: data.orderType,
35    limitPrice: data.limitPrice ? Price(data.limitPrice) : undefined,
36    orderStatus: {
37      status: 'pending',
38      submittedAt: new Date(),
39    },
40  };
41}
42

1import Decimal from 'decimal.js';
2
3// Configure for financial precision
4Decimal.set({ precision: 20, rounding: Decimal.ROUND_HALF_EVEN });
5
6class PreciseMoney {
7  private readonly _amount: Decimal;
8  private readonly _currency: Currency;
9  
10  constructor(amount: string | number, currency: Currency) {
11    this._amount = new Decimal(amount);
12    this._currency = currency;
13  }
14  
15  add(other: PreciseMoney): PreciseMoney {
16    if (this._currency !== other._currency) {
17      throw new Error('Currency mismatch');
18    }
19    return new PreciseMoney(
20      this._amount.plus(other._amount).toString(),
21      this._currency
22    );
23  }
24  
25  multiply(factor: string | number): PreciseMoney {
26    return new PreciseMoney(
27      this._amount.times(factor).toString(),
28      this._currency
29    );
30  }
31  
32  toFixed(decimals: number = 2): string {
33    return this._amount.toFixed(decimals);
34  }
35}
36
37// No floating-point errors!
38const item1 = new PreciseMoney('0.1', 'USD');
39const item2 = new PreciseMoney('0.2', 'USD');
40const total = item1.add(item2);
41console.log(total.toFixed());  // "0.30" (not "0.30000000000000004")
42

1// Only allow transfers between same currency accounts
2type TransferParams<From extends Currency, To extends Currency> = 
3  From extends To
4    ? { from: AccountId; to: AccountId; amount: Money }
5    : never;
6
7function transfer<C extends Currency>(
8  params: TransferParams<C, C>
9): Promise<void> {
10  // Implementation
11}
12
13// This compiles
14transfer<'USD'>({
15  from: AccountId("ACC0000000001"),
16  to: AccountId("ACC0000000002"),
17  amount: Money.USD(100),
18});
19
20// This won't compile - type mismatch enforced at compile time
21// transfer<'EUR'>({
22//   from: AccountId("ACC0000000001"),
23//   to: AccountId("ACC0000000002"),
24//   amount: Money.USD(100),  // ✗ Error!
25// });
26