Functional Programming

A side effect, in one source's list, is anything a function does beyond computing and returning a value: writing to a database, making an HTTP call, writing a file, printing, changing a global variable, throwing an exception. A function that only adds two numbers is pure; one that saves a user and logs it is not.[19] The case against mutable shared state is made at length in a Java book: an order object whose items can be changed by anyone holding a reference, whose total can be read stale from another thread, and whose setters merely redistribute the problem rather than removing it. Functional programming, it concludes, is a set of practical techniques for managing that complexity, not a religion: immutability makes concurrency safe, pure functions allow local reasoning, composition allows reuse, and testing becomes input, function, output.[20] A JavaScript author reaches the same place from the other end, writing objects as literals that return a new instance on every operation so that immutability is forced, while warning that purity should not be an end in itself.[16] In Haskell everything is pure by construction, which one tutorial devotes a chapter to explaining with an analogy before the reader has written much code.[3]

Composition is the mechanism that makes small pure functions add up. Functional-Light JavaScript builds it from a two-function helper to a general compose over any number of functions, by way of a candy-factory analogy, and pauses on the point that trips most readers: the functions execute right to left, but they are listed left to right, matching the order in which they appear when the calls are nested by hand. Partially applying compose itself, the book shows, yields a family of specialised pipelines from one shared prefix.[14] Composing Software takes the widest view: all software design is composition, breaking a problem into smaller problems and composing the solutions, and it treats function composition and object composition as two forms of the same thing.[46] JavaScript Allongé, the "Six" Edition arrives at classes, mixins and decorators by building them from closures, combinators and partial application.[43] What functional and procedural programming share, one source notes, is dividing a program into reusable chunks; what the functional style adds is making those chunks values that can be created, passed around and stored.[18]

Names are the other half of composition. Elements of Clojure treats a name as a layer of indirection separating what a function does from how, and observes that software is written one name at a time, so that programmers may create more names than any other profession; it borrows Frege's distinction between a name's referent and its sense to explain why two variables bound to the same value today are kept separate when they are expected to diverge.[28]

Functional languages describe data with sum types (one of several alternatives) and product types (several things together), and take it apart with pattern matching. Thinking with Types calls pattern matching over algebraic data types one of the style's killer features and then takes the word algebraic literally, counting a type's inhabitants and showing that Either adds, pairs multiply and functions are exponentials.[2] The Science of Functional Programming covers the same ground as disjunctive types and goes on to the Curry–Howard correspondence between types and logical propositions.[30] In Scala the mechanism is visible: a case class gets a companion object with an apply method that constructs and an unapply method that extracts, and The Neophyte's Guide to Scala shows how to write extractors by hand for classes that are not case classes, noting that pattern matching is equally central in Haskell and Erlang.[22]

The practical payoff is what the compiler will refuse. An Elm Primer for React Developers opens with a case expression that forgets one of three animals and prints the compiler's reply, which lists the missing possibility and says it would have to crash on it; the author contrasts that with the helper functions TypeScript developers write to get the same check.[26] An Outsider's Guide to Statically Typed Functional Programming makes the general argument through affordance: a typical language gives no good reason to handle an empty list that cannot happen, whereas a static functional language lets you build a list that cannot be empty, turning what you believe into what the compiler guarantees.[1] The Simple Haskell Handbook does exactly that in its first pages, replacing the plain lists of steps and commands in a continuous integration server's model with non-empty lists, and models the build's progress as a state machine, a function from the old state to the new one.[8]

The same types replace null and exceptions. Finding Success (and Failure) in Haskell grows one password validator through Maybe, Either, newtypes, Applicative and a Validation type, motivated by the wish to report every error in a form rather than halting at the first.[5] Essential F# covers option and result types, discriminated unions and active patterns as the everyday tools of a line-of-business F# codebase.[45] In Java, Functional programming in Modern Java reaches records, sealed types and a chapter titled on the premise that null is not a feature.[20]

No topic in the library has more books devoted to it than the monad, and most of them open by admitting it. Unwrapping Monads & Friends calls writing a monad tutorial a rite of passage and defines the thing in two JavaScript functions, an Identity wrapper and a chain operation, before stating the three laws; a monad, it says, is a pattern rather than a thing, and its instances are what programs contain.[15] Thinking Functionally in PHP names the curse: whoever understands monads becomes unable to explain them, and the terminology varies so much between tutorials and languages that the variation is itself an obstacle to learning.[18] Functional-Light JavaScript opens its preface with the famous one-line definition in terms of monoids and endofunctors and promises never to teach it that way.[14]

The thorough treatments take the opposite approach. Book of Monads runs to five parts: what a monad is and its laws; the State, Reader and Writer monads and monads for failure, logic, mutability, resources and continuations; combining monads with transformers; defining your own, including free and freer monads and extensible effects; and finally the category theory behind the one-line definition, with most code in both Haskell and Scala.[4] The Science of Functional Programming proves that the standard monads satisfy their laws, derives lawful instances of Functor and other type classes from the shape of a type, and reports that monad transformers need eighteen laws.[30] Functional Programming in Javascript maps the vocabulary onto JavaScript, with Identity, IO and Maybe functors built as object literals following the Fantasy Land conventions and brief TypeScript asides for the types;[16] its TypeScript edition starts instead from lenses and monoids, showing a Sum monoid and parenthesis balancing before algebraic data types and functors, and points to the purify and fp-ts libraries for production use.[17] Asynchronous functional javascript applies the same structures to concurrency, treating callbacks as continuation-passing style and promises as a functor and a monad after a tour of the event loop.[21]

On the JVM the abstractions arrive as libraries. Mastering Advanced Scala explains implicit parameters and conversions, type erasure and the type class pattern as the groundwork, then tours ScalaZ and Cats: monoids, functors, monads, transformers, Reader, Writer, State and Free, starting with ScalaZ's disjunction as an alternative to Either and Try.[23] Functional Programming for Mortals builds the same material on Scalaz for the sceptical Scala developer with a Java background, with a web application as the running example.[44] In Clojure, Functional Programming for the Object-Oriented Programmer introduces monads in a chapter on avoiding if expressions and keeps two further chapters on them optional.[33] For Haskell, Haskell (almost) Standard Libraries maps the abstractions to packages, with chapters on functors, transformers and effect systems alongside mtl and rio.[9]

Optics are the functional answer to reading and updating a value deep inside an immutable structure. Optics By Example defines them as a family of inter-composable combinators for bidirectional data transformations, with lenses, folds, traversals, prisms and isos as the main kinds, and lists what they buy: composition, since each optic picks up where the previous one left off; separation of the choice of data from the operation on it, which the author offers as a replacement for the visitor pattern; concision, illustrated by a one-line sum over the costs in a JSON document; and a stable interface over a changing data layer. Its weaknesses are listed as honestly: ugly type errors, and implementations that differ between the Haskell, Scala and PureScript libraries.[10] Lenses for the Mere Mortal: PureScript Edition teaches the same material in PureScript organised by the kind of data rather than the kind of optic, insists on the word optic for the idea and lens for one type, and starts with view, set and over on tuples and records.[35]

Outside Haskell the idea travels well. Functional Programming in TypeScript presents lenses as functional getters and setters, extracting a class's getter into a standalone function so that it can be mapped over a list of clients and composed point-free.[17] Functional programming in Modern Java devotes two parts to lenses, prisms and traversals built from records and sealed types.[20] Clojure's equivalent for nested data is the Specter library, whose selectors go beyond get-in to select or transform many leaves at once and to walk code; Extending and Using Specter teaches it by having the reader rebuild its API on a navigator protocol.[29] Composing Software covers lenses and transducers in JavaScript,[46] and Haskell (almost) Standard Libraries lists the optics packages and the ones that focus on JSON documents.[9]

The Haskell shelf is the deepest and the most candid. Production Haskell is the view from industry: managing complexity is the most important and difficult task in a Haskell project, which it says twice; a project has a complexity budget and a novelty budget, spent on fancy and on unfamiliar technology respectively, and choosing Haskell has already spent much of both; and the community's tolerance for complexity comes from the confidence that strong types give. Its parable of two cars ends with the advice to take the slow one that fails predictably if you need to get to work.[6] The Haskell Blueprint answers the reputation for impracticality with an engineering-first guide that runs from functions and type classes to Cabal, Hspec testing and deployment and ends with a complete blog engine on a hexagonal architecture.[39]

The project books each pick one substantial thing to build. Sockets and Pipes starts from the question of what exactly a web server is, implements HTTP from file handles and bytes up through sockets, following the RFC 9110 and 9112 definitions, and takes in monad transformers, resource safety, streaming and typed errors on the way; it needs GHC 9.2 or 9.4 and ships a companion package that re-exports every library it uses.[7] The Simple Haskell Handbook builds a continuous integration server that runs its steps in Docker containers, in a deliberately restricted subset of the language, and shows the refactoring rather than hiding it; after the domain model it moves to the Docker Engine API, JSON, dependency injection, tests, STM and a CLI.[8] Haskell (almost) Standard Libraries exists because Haskell's base library is slim: it surveys the community's preferred packages by task across twenty-five chapters, from containers, text and bytes to parsing, optics, streaming, async, STM and web applications, with a one-page summary mapping tasks to packages.[9]

The tutorials span the whole range. Happy Learn Haskell Tutorial Volume 1 takes a complete beginner through values, types, IO, purity and functions that return functions;[3] Finding Success (and Failure) in Haskell grows one program from case expressions to applicative validation;[5] Optics By Example and Thinking with Types are the advanced references on optics and on type-level programming;[10] and Functional Design and Architecture (Early Edition, 2020), an early edition its author has since reworked for another publisher, opens with the case that software design matters as much in Haskell as anywhere and sets out two projects, a spaceship control simulator and a web-service framework, to show it.[11]

Two Haskell-shaped languages compile to JavaScript. PureScript, in the words of PureScript by Example, is a small, strongly and statically typed language inspired by Haskell, made to bring disciplined functional programming to large JavaScript applications; its chapters are each motivated by a problem, an address book, canvas graphics, a text adventure, and introduce applicative validation, effect monads, monad transformers and free monads in solving them, though its tooling chapter dates from 2017.[42] Functional Programming Made Easier is the long beginner's path through the same language, from functions and type classes to effects, a JSON library, the foreign function interface and a full-stack application with HTTPure and Halogen.[37] Lenses for the Mere Mortal: PureScript Edition assumes only shallow PureScript and teaches optics in it.[35]

Elm trades features for focus. An Outsider's Guide to Statically Typed Functional Programming credits it with the best error messages, documentation written in plain language and a read-eval-print loop that tries not to surprise, but notes that it offers very limited polymorphism, which is why the book moves on to PureScript to show what is missing.[1] An Elm Primer for React Developers presents the trade from the React side: exactly one architecture, the Elm Architecture of a model, an update function and a view; exactly one way to represent side effects; and a compiler strict enough that a program that compiles is very likely to work. It is frank about the costs, a smaller ecosystem, a learning curve and hiring, and shows how to adopt the language one widget at a time inside an existing React application.[26]

Scala's books divide by how functional they want the language to be. Modern Web Development with Scala is the pragmatic end: it dates the language's rise to Twitter's 2008 rewrite, describes Scala as high-level syntax without the performance cost, and teaches it by building a Play application with one chapter on functional concepts along the way, on Scala 2.13 and Play 2.8.[24] The Neophyte's Guide to Scala picks up where a first course leaves off, with the everyday idioms (extractors, Option, Try and Either, futures, type classes) in sixteen articles that date from 2012 and 2013.[22] Mastering Advanced Scala names Play as the approachable framework a newcomer should start with and then goes where that book does not, into implicits, type classes and the purely functional libraries.[23]

The purely functional end has its own canon. Functional Programming for Mortals is written for the sceptical Scala developer with a Java background and builds a web application on Scalaz, with for comprehensions, algebras, type class derivation and advanced monads on the way.[44] Practical FP in Scala takes a shopping cart service from design through its HTTP layer, persistence and cache to testing and a Docker image with continuous integration, on Cats Effect, Fs2, Http4s and Skunk.[36] Pure functional HTTP APIs in Scala specifies one small web service and implements it twice, first with Akka HTTP and Slick and then purely with Cats Effect, http4s and Doobie, so that models, routes, tests and benchmarks can be compared side by side; its second edition migrates the project to Scala 3.[47] Effect Oriented Programming is the ZIO introduction, framing network calls, user input and failure as the effects that make software unpredictable and showing retries, timeouts and fallbacks before the machinery.[48] Scalapedia is a 746-page reference across the whole ecosystem, edited with AI assistance by its own account,[51] and The Science of Functional Programming uses Scala for its examples while saying that most of its material applies to any functional language.[30]

Clojure is the library's Lisp. Functional Programming for the Object-Oriented Programmer describes it as a small core surrounded by many library functions, running on the Java virtual machine (which is why the REPL takes a few seconds to appear), and uses it to teach object-oriented programmers the elements of functional style: data flowing through functions, functions that make functions, laziness, zippers and pattern matching.[33] Foundations of Clojure covers the language's core in order, from functions and threading expressions through sequences, destructuring and control structures to managed state with atoms and refs, macros, namespaces and polymorphism.[49]

The two short essays on the shelf are about judgement. Clojure Polymorphism solves one data-transformation problem three ways, as a plain function with a cond, a multimethod and a protocol, and compares them for flexibility, performance, external integration and cross-platform code; its principles include never extending an abstraction you do not own to a type you do not own, letting library users pass in a function rather than defining a multimethod or protocol for them, and reaching for protocols as the usual balance.[27] Elements of Clojure is about names, idioms, indirection and composition, written for people who know the language but struggle to explain their design decisions.[28] Extending and Using Specter is the one library guide, for working with nested data.[29]

The Elixir books in the library are application books rather than language books, so the functional ideas appear in use. Toy Robot - The Elixir Version works the Toy Robot interview exercise from a Mix application through pattern-matching styles, ExUnit tests and doctests to a command interpreter and a command-line interface, then turns it into a supervised multiplayer game with GenServer and DynamicSupervisor.[57] Building Conduit builds a blogging platform in Elixir and Phoenix with command query responsibility segregation and event sourcing on the Commanded library, with aggregates, domain events and read-model projections.[58] Phoenix Product Codex follows the author building a product-data REST API for a family industrial-equipment business, on Elixir 1.18 and Phoenix 1.7, modelling suppliers, brands and variants with Ecto changesets and generating typo-resistant item codes with a Markov chain; it is a work in progress by its own notice.[41]

Essential F# is the one F# book, free, and grown from blog posts on a company's website: the core of what a developer needs to work on one of its line-of-business codebases, from domain modelling and functions through null and exception handling, collections, recursion and computation expressions to three chapters on web programming with Giraffe, with the code upgraded to F# 5 and run in VS Code with the ionide extension.[45]

JavaScript has functions as values and closures built in, and its books argue about how far to go. Functional-Light JavaScript draws the line at what it calls functional-light programming, a subset the author reached pragmatically and experientially rather than academically, covering function inputs, composition, side effects, immutability, closures versus objects, recursion, list operations and async, with transducers and monads in appendices and library versions from 2017 and 2018.[14] JavaScript Allongé, the "Six" Edition starts from values and expressions and builds the language's classes and mixins from functions, for ECMAScript 2015.[43] Composing Software covers pure functions, currying, functors, monads, object composition, factory functions, mixins, lenses and transducers, and began as a series of blog posts.[46] Unwrapping Monads & Friends builds Identity, Maybe, Reader, State and IO in plain JavaScript using the Monio library for examples, and is free to read online under another title.[15] Functional Programming in Javascript and Asynchronous functional javascript are the category-theory treatments, the second one still visibly in progress in its sample.[21]

TypeScript adds the types. Functional Programming in TypeScript builds the structures by hand in typed code and names purify and fp-ts as the two mature libraries for production use.[17] Multi-Paradigm Programming uses TypeScript to argue that functional, object-oriented and imperative styles belong together, treating iterators, generators and Lisp's code-as-data as one idea and applying it to asynchronous code and front-end applications; its first three chapters are published on GitHub.[50] An Elm Primer for React Developers is the book for a TypeScript developer who wants to see what the discipline looks like when the compiler enforces it.[26]

Java's functional books are recent and practical. Functional programming in Modern Java covers Java 8 through 25, from the case against mutable shared state through immutability, pure functions, composition, records and sealed types, null handling and streams to error handling without exceptions, containing side effects and optics.[20] Java Backend Coding Technology presents a complete coding methodology for Java 21 and later backends, with six structural patterns and a supporting library, aimed at teams whose code is written by humans and AI assistants together.[19] Modern Java: Second Edition places the lambdas, streams, records and pattern matching in the wider history of a language first developed in the 1990s and owned by Oracle since 2010, and counts Groovy and Scala among the other languages that compile to its bytecode.[32]

Thinking Functionally in PHP is the most complete of the single-language treatments: four parts covering pure and first-class functions, immutability and recursion; the category theory underneath, functors, monads and algebraic data types; applying Maybe and Either to null handling and errors; and a survey of functional-language features with advice on when to go functional. It is tied to PHP 7.4, whose short lambdas prompted it, and it classes PHP with C++, Java and C# as class-based object-oriented languages.[18] A Go Developer's Notebook is an exploratory Go book, in pre-generics Go, with functional programming as one part among networking, encryption, caching and concurrency.[34] Modern Software Design in Fortran redesigns Fortran code with ideas from contemporary paradigms, including a chapter on functional programming beside derived types, polymorphism and test-driven development, in a language without exceptions.[56]

Functional Design and Architecture (Early Edition, 2020) sets out a methodology its author calls Functional Declarative Design, built on hierarchical free monads, and divides its material into an introduction, domain-driven design and designing real-world software, with requirements, layering, embedded domain-specific languages, state, concurrency, persistence and testing covered through two projects; the author says the second project's ideas have been tested in production.[11] Layerd FP in Scala treats Clean Architecture, hexagonal ports and adapters and the onion model as one family of ideas, dependencies pointing inward and technology at the edges, and enforces the rule in real Scala 3 modules for a SaaS billing domain whose core has no effect system in it at all.[55] The Haskell Blueprint ends on the same shape, a blog engine on hexagonal architecture and domain-driven design.[39] Algebra-Driven Design argues that this is the missing discipline, and Production Haskell adds the organisational side: selling the language, hiring for it, the ReaderT pattern for application structure and the cost of every novelty.[6]

The Scala shelf carries the library's distributed-systems work. Functional Event-Driven Architecture builds a trading system in purely functional Scala 3 on Apache Pulsar and Fs2 streams, with a WebSockets service on Http4s and two small web applications, and says its concepts translate to Kafka, RabbitMQ or other brokers.[52] Practical Event Sourcing with Scala takes event sourcing out of its enterprise framing, deliberately avoiding domain-driven design and CQRS vocabulary, and builds a question-and-answer web application on Play, Akka Streams, Kafka and Neo4J with a React front end and a time-travel dashboard that rewinds the event log; its sample is mostly environment setup on JDK 8.[25] Event Sourcing in Scala does the modern version in Scala 3 and ZIO: events as sealed families, state as a pure fold over history, commands as a decide function, an append-only PostgreSQL store and projection workers walked in reading order.[53] Saga Architecture in Scala implements one order-placement flow twice, as orchestration with an explicit saga step type and as choreography with events and reactions, with compensating actions for partial failure.[54]

Effects are the hinge on which these systems turn. Effect Oriented Programming makes retries, timeouts, fallbacks and resource finalisation the first thing a reader sees of ZIO, then covers dependency injection, testing, shared state and resilience patterns such as circuit breaking.[48] Pure functional HTTP APIs in Scala measures the pure and impure versions of one service against each other with tests and benchmarks.[47] Sockets and Pipes adds STM, chunked streaming and ExceptT errors to its hand-built server,[7] and The Simple Haskell Handbook reaches STM, agents and webhooks in its CI server.[8] On the BEAM, Building Conduit shows the event-sourced version of a web application with its read model and integration tests.[58]