0.0  Prologue

Declarative Code Story surveys the core features of declarative programming languages - the constructs that describe what to compute rather than how to compute it. Starting from pure expressions and immutable values, and moving through types, pattern matching, functions-as-values, recursion, combinators, lazy evaluation, monads, type classes, persistent data structures, declarative concurrency, and query/rule systems, each chapter covers one feature category in depth.

Why study declarative features?

1. Declarative code is shorter and closer to the problem specification. A SQL query or a Haskell list comprehension expresses intent directly; the equivalent imperative loop buries intent in mechanics.
2. Immutability and referential transparency eliminate entire categories of bugs: data races, aliasing surprises, and state inconsistencies that are impossible when values cannot be mutated in place.
3. Functional patterns - map, filter, fold, composition - are now mainstream in Rust, C#, Python, and JavaScript. Understanding the functional model makes these APIs predictable rather than ad hoc.
4. Type classes, monads, and effect systems are the vocabulary of modern library design. Reading Rust trait bounds or Haskell type signatures requires fluency in these concepts.
5. Laziness and persistent data structures enable algorithms that would be awkward or impossible to express imperatively without significant plumbing.

Examples draw primarily from Haskell (the canonical purely functional language), F# (.NET functional), Rust (strong functional features), and Python (accessible functional idioms). SQL appears in the queries chapter.

0.1  Popular Declarative Languages

Language	Description
SQL	Relational query language; specifies data retrieval with SELECT/WHERE/JOIN without controlling the execution plan.
Haskell	Purely functional, lazy-by-default language with strong static typing, type classes, and monads.
Prolog	Logic programming language; programs are facts and rules; queries derive conclusions by resolution and unification.
Erlang	Concurrent, fault-tolerant functional language built on isolated actor processes communicating by message passing.
Clojure	Functional Lisp on the JVM; immutable persistent data structures and software transactional memory for concurrency.
F#	Functional-first language on .NET; type inference, algebraic types, pattern matching, and computation expressions.
Elixir	Functional language on the Erlang VM; actor model, fault tolerance, and a modern metaprogramming-friendly syntax.
OCaml	Statically typed functional language with algebraic types, pattern matching, and a high-performance native compiler.
Scala	JVM language combining functional and object-oriented styles; higher-kinded types, for-comprehensions, and implicits.
R	Statistical computing language; vector operations, functional data pipelines, and declarative plotting with ggplot2.

0.2  Getting Started

Familiarity with at least one language that has first-class functions (Rust, C#, Python, JavaScript) is sufficient background. Each chapter is self-contained - skip what you know. The Pages list at the lower right navigates between chapters.

1. Start with Expressions (Chapter 1) if you want to understand the foundation that distinguishes declarative from imperative thinking.
2. Start with Pattern Matching (Chapter 3) if you are coming from an imperative background and want the most immediately practical payoff.
3. Start with Monads (Chapter 8) if you need to read Haskell, F#, or advanced Rust and the terminology is blocking you.
4. Start with Queries (Chapter 12) if your focus is SQL, LINQ, or logic programming.

0.3  Story Content

Each chapter covers one declarative language feature category and its sub-topics as page sections. The full sequence:

Chapter	Topics
0 – Prologue	Motivation, layout, and references for the Declarative Code Story.
1 – Expressions & Values	Pure expressions, immutable values, value semantics, referential transparency.
2 – Types & Type Inference	Algebraic data types, Hindley-Milner inference, phantom types, dependent and refinement types.
3 – Pattern Matching & Destructuring	Exhaustive structural matching, nested patterns, guards, record destructuring.
4 – Functions as Values	Pure functions, first-class and higher-order functions, composition, currying and partial application.
5 – Recursion	Structural recursion, mutual recursion, corecursion and infinite structures, tail call optimization.
6 – Higher-Order Functions & Combinators	map, filter, fold; scan, zip, unfold; applicative and monoidal operations; point-free composition.
7 – Lazy Evaluation	Call-by-need semantics, thunks, infinite streams and sequences, lazy vs strict modes.
8 – Monads & Effects	Option/Maybe, Result/Either, list monad, IO and state monads, effect systems.
9 – Type Classes & Interfaces	Ad-hoc polymorphism, instance derivation, higher-kinded types, Functor/Applicative/Monad hierarchy.
10 – Immutability & Persistent Data	Persistent lists, trees, maps; structural sharing; transient optimization; copy-on-write.
11 – Declarative Concurrency	Software transactional memory, actor model, functional reactive programming, dataflow and streaming.
12 – Queries & Rules	Relational queries, logic rules and unification, constraint satisfaction, pattern-based rewriting.
13 – Projects	Ten declarative programming projects, each instructive and producing a useful program or library.

0.4  References

Reference	Description
Haskell Documentation	Official Haskell language documentation, tutorials, and library references.
F# Documentation - Microsoft	Language reference, tutorials, and API docs for F# on .NET.
The Rust Programming Language	Covers Rust’s functional features: iterators, closures, pattern matching, and traits.
Learn You a Haskell for Great Good	Approachable introduction to Haskell covering types, type classes, and monads.
PostgreSQL SQL Reference	Comprehensive reference for SQL syntax, queries, and extensions.