Functional Programming in Finance: Why Immutability Matters

1// Dangerous: shared mutable state
2class PortfolioManager {
3  private positions: Map<string, number> = new Map();
4  
5  calculateRisk() {
6    // What if positions changes during calculation?
7    let totalRisk = 0;
8    for (let [symbol, quantity] of this.positions) {
9      totalRisk += getRisk(symbol, quantity);
10    }
11    return totalRisk;
12  }
13  
14  updatePosition(symbol: string, quantity: number) {
15    this.positions.set(symbol, quantity);
16  }
17}
18

1type position = {
2  symbol: string;
3  quantity: int;
4  avg_price: float;
5}
6
7type portfolio = position list
8
9let calculate_risk (portfolio: portfolio) : float =
10  List.fold_left 
11    (fun acc pos -> acc +. get_risk pos.symbol pos.quantity)
12    0.0
13    portfolio
14
15(* Creating a new portfolio with updated position *)
16let update_position (portfolio: portfolio) (symbol: string) (qty: int) : portfolio =
17  let updated_pos = { symbol; quantity = qty; avg_price = 0.0 } in
18  updated_pos :: List.filter (fun p -> p.symbol <> symbol) portfolio
19

1type account_state = {
2  balance: float;
3  timestamp: float;
4  version: int;
5}
6
7let apply_transaction state amount =
8  { balance = state.balance +. amount;
9    timestamp = Unix.gettimeofday ();
10    version = state.version + 1 }
11
12(* Full audit trail preserved *)
13let history = 
14  initial_state
15  |> apply_transaction 1000.0
16  |> apply_transaction (-200.0)
17  |> apply_transaction 500.0
18

1(* Multiple threads can safely read the same portfolio *)
2let worker_threads = List.init 10 (fun i ->
3  Thread.create (fun () ->
4    let risk = calculate_risk shared_portfolio in
5    process_risk_result i risk
6  ) ()
7)
8

1type trade_event = 
2  | OrderPlaced of order
3  | OrderFilled of execution
4  | PositionUpdated of position
5
6let replay_events events =
7  List.fold_left 
8    (fun state event -> apply_event state event)
9    initial_state
10    events
11
12(* Debug by replaying exact sequence *)
13let debug_state = replay_events problematic_events
14

1type order_type = Market | Limit of float | Stop of float
2type order_status = Pending | Filled | Rejected of string
3
4let validate_order order market_price =
5  match order.order_type, order.status with
6  | Market, Pending -> Ok order
7  | Limit price, Pending when price > 0.0 -> Ok order
8  | Stop price, Pending when price > 0.0 -> Ok order
9  | Limit price, Pending -> Error "Invalid limit price"
10  | _, Filled -> Error "Order already filled"
11  | _, Rejected reason -> Error ("Previously rejected: " ^ reason)
12  | _ -> Error "Invalid order state"
13

1// Imperative (error-prone)
2function reconcile(trades: Trade[], executions: Execution[]) {
3  let matched = [];
4  let unmatched = [];
5  
6  for (let trade of trades) {
7    let found = false;
8    for (let exec of executions) {
9      if (trade.id === exec.tradeId) {
10        matched.push({ trade, exec });
11        found = true;
12        break;
13      }
14    }
15    if (!found) unmatched.push(trade);
16  }
17  return { matched, unmatched };
18}
19

1(* Functional (clear and correct) *)
2type reconciliation_result = {
3  matched: (trade * execution) list;
4  unmatched_trades: trade list;
5  unmatched_executions: execution list;
6}
7
8let reconcile trades executions =
9  let execution_map = 
10    List.fold_left 
11      (fun map exec -> StringMap.add exec.trade_id exec map)
12      StringMap.empty
13      executions
14  in
15  
16  let matched, unmatched_trades =
17    List.partition_map
18      (fun trade ->
19        match StringMap.find_opt trade.id execution_map with
20        | Some exec -> Left (trade, exec)
21        | None -> Right trade)
22      trades
23  in
24  
25  let matched_ids = List.map (fun (t, _) -> t.id) matched in
26  let unmatched_executions = 
27    List.filter 
28      (fun exec -> not (List.mem exec.trade_id matched_ids))
29      executions
30  in
31  
32  { matched; unmatched_trades; unmatched_executions }
33

1// Pure function
2function calculatePnL(position: Position, price: number): number {
3  return (price - position.avgPrice) * position.quantity;
4}
5
6// Instead of
7class Position {
8  calculatePnL() {
9    this.pnl = (this.currentPrice - this.avgPrice) * this.quantity;
10  }
11}
12

1import { produce } from 'immer';
2
3const newPortfolio = produce(portfolio, draft => {
4  const pos = draft.positions.find(p => p.symbol === 'AAPL');
5  if (pos) pos.quantity += 100;
6});
7

1┌─────────────────────────────────────────────────┐
2│  Imperative Shell                               │
3│  (I/O, databases, APIs, side effects)           │
4│                                                 │
5│  ┌───────────────────────────────────────────┐  │
6│  │  Functional Core                          │  │
7│  │  (Pure business logic, no side effects)   │  │
8│  │                                           │  │
9│  │  • Immutable data structures              │  │
10│  │  • Pure functions                         │  │
11│  │  • Type-safe business rules               │  │
12│  └───────────────────────────────────────────┘  │
13└─────────────────────────────────────────────────┘
14           ↓ (compiled to)
15┌─────────────────────────────────────────────────┐
16│  Hardware Layer (always imperative)             │
17│  • CPU instructions executed sequentially       │
18│  • Memory mutations in RAM and cache            │
19│  • Registers updated with each instruction      │
20└─────────────────────────────────────────────────┘
21

1let result = List.map (fun x -> x * 2) numbers
2

1; Simplified assembly
2mov rax, [numbers]      ; Load address
3loop:
4  mov rbx, [rax]        ; Load value (mutation!)
5  shl rbx, 1            ; Multiply by 2 (mutation!)
6  mov [result], rbx     ; Store result (mutation!)
7  add rax, 8            ; Next element (mutation!)
8  jmp loop
9