This approach contrasts with imperative languages where computation proceeds by mutating a state over time (e.g., a running total). Functional programming is more declarative, like a mathematical expression or a spreadsheet cell that calculates its value based on others, making it easier to reason about.
The dream of hardware optimized for functional programming (e.g., dataflow or SK combinator machines) proved to be a mistake. These machines were essentially hardware-based interpreters. The better approach is to build a sophisticated compiler that translates functional code into efficient instructions for general-purpose CPUs.
Most compilers use complex, untyped intermediate representations. GHC desugars Haskell into a tiny, statically-typed language called Core. This allows a type-checker to run after each optimization pass, immediately catching bugs in the compiler that would otherwise manifest as cryptic runtime segfaults in the final compiled program.
In imperative code, functions can silently read or write shared global variables, creating invisible and dangerous dependencies. Functional programming forces these interactions to be explicit (e.g., through function arguments or monads), encouraging a more modular and less coupled design that is easier to reason about and maintain over time.
Haskell's lazy evaluation means the order of operations is not guaranteed, making side effects like `print` statements unpredictable. This forced the language to be pure by default. Conversely, OCaml's strict, predictable evaluation order made it easy to incorporate I/O and side effects, allowing it to be impure by default.
Lazy evaluation allows programmers to modularly separate producer and consumer logic (e.g., an infinite data generator and a selective consumer) that would have to be merged in a strict language. For example, one can generate an infinite chess game tree and have a separate function explore only the necessary branches.
The power of monads isn't just to sequence side effects, but to treat those entire sequences as first-class values that can be passed, stored, and reused. Unlike in C, Haskell's `do` notation bundles I/O operations into a value (e.g., of type `IO unit`) that can be composed and manipulated like any other data.
Beyond catching compile-time errors, a strong static type system's main benefit is making large, aging codebases maintainable. Dynamically typed programs can become immutable as original authors leave. With static types, a developer can fearlessly refactor a 35-year-old codebase by letting the compiler guide them to all necessary changes.
With hundreds of millions of users writing formulas, Excel's side-effect-free, value-based computation model makes it a massive, unintentional functional programming environment. Recognizing this, Simon Payton Jones successfully advocated for adding Lambda functions, making Excel's formula language Turing-complete.
This phrase can be read two ways: "avoid success, whatever the cost," or "avoid the kind of success that comes at the cost of your principles." For Haskell, it meant not compromising core ideas for mass appeal. It also warns that too many users can create immense backward-compatibility pressure, hindering future innovation.
Despite vastly different approaches—one based on mutating a tape, the other on pure value reduction—Alan Turing and Alonzo Church's models of computation were proven to be equally powerful. This historical context reveals that the choice between paradigms is about usability and reasoning, not computational limits.
An LLM generating code can use a static type checker as a rapid verifier. This allows the model to iterate and correct its own type errors internally before presenting the final code. This dramatically constrains the problem space and improves the quality of the generated output, making static typing a boon for LLMs.
Unlike languages like C which started as useful but unsafe, Haskell began with extreme safety and theoretical purity, even lacking I/O initially. This forced its designers to invent new, principled ways to handle side effects (like monads), ensuring the language evolved towards usefulness without sacrificing its core value of safety.