Functional programming
Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.
Functional Programming in JavaScript
A programming paradigm that builds software by composing and transforming functions, typically emphasizing pure functions and immutable data over mutable state and side effects.
- How it is used
- Reframes JavaScript application design around functions to control growing shared-state complexity.
- How deep it goes
- Defines the style, contrasts imperative rewrites, and introduces decomposition, chains, composition, and reactive events without fully developing each technique.
- Examples
- Uses Hello World DOM output, counters, student display and SSN validation, enrollment grades, and collection transformations.
- What you can do after
- Apply functional techniques in JavaScript by decomposing tasks, composing functions, and chaining data transformations.
Read how Functional Programming in JavaScript explains functional programming →
Grokking Simplicity
A programming paradigm that emphasizes composing computations as evaluations of functions while minimizing mutable state and side effects.
- How it is used
- Organizes software by separating time-sensitive actions from stable calculations and inert data.
- How deep it goes
- Explains definitions, tradeoffs, and classification of code, then stops short of language-specific implementation details.
- Examples
- Uses a task-management service, email notifications, and distinctions among task data, notification calculations, and sending actions.
- What you can do after
- Diagnose/debug bugs by identifying actions, then apply extraction of calculations to improve testing, reuse, and understanding.
Read how Grokking Simplicity explains functional programming →
The Joy of JavaScript
A programming paradigm that models computation as the evaluation of functions, often emphasizing immutability and function composition.
- How it is used
- Recasts application calculations as pure transformations instead of loops that update shared state.
- How deep it goes
- Defines purity and works through a wallet-balance refactoring, while leaving broader functional programming beyond this treatment.
- Examples
- Uses block validation with filter, map, and reduce, then refactors a wallet-balance calculation from nested loops into an array pipeline.
- What you can do after
- Practice/perform a refactoring that extracts a pure balance calculation while retaining a delegating Wallet method.
Read how The Joy of JavaScript explains functional programming →
Functional Design and Architecture: Examples in Haskell
A programming approach that represents computation primarily through the evaluation and composition of functions, favoring immutable data and minimized side effects.
- How it is used
- Uses functional design to control complexity and reason about correctness, parallelism, and application architecture.
- How deep it goes
- Explains purity, immutable bindings, composition, and effect separation with examples, while comparing functional and object-oriented design principles.
- Examples
- Illustrates pure maximum calculation with separate output, and maps string lengths over lists.
- What you can do after
- Evaluate design choices using purity, immutability, and explicit effect handling to reason about predictability and complexity.
Read how Functional Design and Architecture: Examples in Haskell explains functional programming →
Unit Testing Principles, Practices, and Patterns
Functional programming is a programming paradigm that expresses computation through mathematical functions and minimizes hidden inputs, hidden outputs, and mutable state.
- How it is used
- Supports output-based unit testing by making computation explicit and minimizing hidden behavior.
- How deep it goes
- Defines pure functions and functional architecture, but stops short of a deep functional-programming treatment.
- Examples
- Uses CalculateDiscount, Increment, and AddComment to contrast explicit computation with internal state and side effects.
- What you can do after
- Apply functional principles to separate business decisions from side effects and write more output-based tests.
Read how Unit Testing Principles, Practices, and Patterns explains functional programming →
The Art of Code
A programming style that combines function-oriented composition with declarations of desired results rather than procedural commands.
- How it is used
- Uses functional composition to make transformations visible and reduce risks from hidden state and side effects.
- How deep it goes
- Defines purity and referential transparency, then works through pipelines, absence handling, and readability and performance tradeoffs.
- Examples
- Compares word-filtering loops and streams, chains Optional price retrieval, and analyzes youngest and oldest people alongside sorted names.
- What you can do after
- Apply functional composition via Java streams and Optional while evaluating readability, side effects, and traversal costs.
Functional Programming in C#, Second Edition
Functional programming is a programming paradigm that builds programs by composing functions and favors functions whose behavior depends only on their inputs.
- How it is used
- Introduces functional programming as a practical alternative to imperative state mutation in C# development.
- How deep it goes
- Explains first-class functions and mutation avoidance through sequence operations and concurrency contrasts, then extends the approach to immutable state snapshots.
- Examples
- Uses LINQ filtering, sorting, and mapping alongside concurrent array summation and sorting.
- What you can do after
- Apply it via LINQ to compose sequence transformations without mutating the input.
Read how Functional Programming in C#, Second Edition explains functional programming →
Functional Programming in Scala, Second Edition
Functional design is the practice of structuring software around pure functions, immutable data, composition, and explicit effects.
- How it is used
- Organizes programs around pure cores while isolating I/O, errors, and other effects at their boundaries.
- How deep it goes
- Defines purity and side effects, explains substitution and explicit state, then extends the approach through library and I/O design.
- Examples
- Uses coffee charges, random number generation, integer summation, property-based testing, parser libraries, and stream processing.
- What you can do after
- Apply it by separating effects from pure calculations, modeling state explicitly, and composing small reusable functions.
Read how Functional Programming in Scala, Second Edition explains functional programming →
Learn Haskell by Example
Functional programming is a programming paradigm that treats computation primarily as the evaluation of functions and the transformation of values.
- How it is used
- Frames Haskell development as composing immutable transformations for safe, reusable, and reliable software.
- How deep it goes
- Defines declarative, immutable, and pure programming; enumerates forbidden effects while deferring their control through monadic programming.
- Examples
- Uses contrasting chocolate-cake recipes and later beginner tools, including word-ladder AI and CSV formatting, to ground the approach.
- What you can do after
- Evaluate/understand programs as value transformations and recognize when mutable state or direct effects conflict with purity.
Read how Learn Haskell by Example explains functional programming →
Deep Learning with JAX
A programming style centered on functions as values and minimal reliance on mutable state.
- How it is used
- Structures JAX machine-learning programs for explicit state, pure functions, and composable transformations.
- How deep it goes
- Explains purity, explicit state, immutability, and indexed updates, while deferring random-number details and control-flow habits.
- Examples
- Uses explicit neural-network state, JAX random state, and .at[] replacements for NumPy-style in-place updates.
- What you can do after
- Apply via JAX functions that pass parameters and state explicitly and replace mutation with functional array updates.
Read how Deep Learning with JAX explains functional programming →
F# in Action: A Revised Edition of Get Programming with F#
Functional programming is a programming paradigm that emphasizes composing computations as functions and minimizing mutable state and side effects.
- How it is used
- Organizes application behavior around functions acting on immutable data, including domain models and HTTP requests.
- How deep it goes
- Explains the approach through a basket comparison and identifies expressions and immutability as priorities without requiring pure functions.
- Examples
- Contrasts a stateful shopping basket with an immutable record and stateless functions, then compares HTTP requests with function calls.
- What you can do after
- Practice/perform it by rewriting a familiar module in F#, favoring immutable values and expressions over mutable variables and statements.
The Art of Unit Testing 3e
A programming paradigm that emphasizes function composition, expressions, and minimizing mutable state and side effects.
- How it is used
- Uses functional design to replace dependencies in unit tests through function parameters.
- How deep it goes
- Works through adapter injection and a stubbed test, but does not establish that the whole design is stateless.
- Examples
- Tests a website-checking function with a supplied network stub and contrasts it with a directly imported adapter.
- What you can do after
- Build it from scratch by passing a network adapter into a function and supplying a stub during tests.
Read how The Art of Unit Testing 3e explains functional programming →
C++ Concurrency in Action, Second Edition
Functional programming is a programming style that emphasizes computing results from inputs while avoiding mutable external state.
- How it is used
- Structures concurrent tasks around their inputs and future-delivered results instead of direct shared-data exchange.
- How deep it goes
- Defines pure functions and relates them to concurrency, then demonstrates future-based Quicksort without developing a broad functional-programming toolkit.
- Examples
- Uses mathematical functions, basic arithmetic, and sequential and future-based Quicksort examples.
- What you can do after
- Apply via C++ futures to pass task results between threads without explicit shared-data access.
Read how C++ Concurrency in Action, Second Edition explains functional programming →
The Well-Grounded Rubyist, Fourth Edition
A functional language is a programming language that emphasizes computation through functions and minimizes mutable state and side effects.
- How it is used
- Frames functional programming as a style for writing predictable code and weighing design trade-offs alongside object-oriented programming.
- How deep it goes
- Defines pure functions and referential transparency, then illustrates mutation, exceptions, currying, and lazy sequences without deep mathematical treatment.
- Examples
- Contrasts reassigning an incremented variable with creating a new one, and demonstrates curried functions and lazy infinite sequences.
- What you can do after
- Apply currying and lazy enumerators to create reusable functions that process finite portions of infinite sequences.
Read how The Well-Grounded Rubyist, Fourth Edition explains functional programming →
Kotlin in Action, 2E
Functional programming treats computation primarily as the evaluation and composition of functions, often emphasizing immutable data and limited side effects.
- How it is used
- Uses functions, immutable values, and collection operations to make Kotlin code concise, reusable, testable, and safer for concurrent development.
- How deep it goes
- Defines first-class functions, immutability, and pure functions, then demonstrates lambdas and collection operations without descending into implementation internals.
- Examples
- Uses a button listener lambda and a message pipeline applying filter, map, distinct, and sortedBy.
- What you can do after
- Apply it via Kotlin lambdas and standard collection functions to compose behavior and express data transformations.
Read how Kotlin in Action, 2E explains functional programming →
Python Workout: 50 ten-minute exercises
Functional programming is a programming paradigm that emphasizes composing functions, minimizing mutable state, and transforming inputs into outputs.
- How it is used
- Uses immutable data, short functions, and input-to-output transformations to make programs easier to test, debug, and maintain.
- How deep it goes
- Explains immutability, state avoidance, higher-order functions, map, filter, and comprehensions, but stops short of formal theory.
- Examples
- Demonstrates squared even numbers, word-length mapping, long-word filtering, and parallel letter-number multiplication.
- What you can do after
- Apply functional techniques through Python comprehensions, map, and filter to transform iterable data without direct mutation.
Read how Python Workout: 50 ten-minute exercises explains functional programming →
Go in Practice, Second Edition
Functional programming is a programming paradigm that emphasizes function composition, expressions, and controlled handling of state and side effects.
- How it is used
- Contrasts functional programming with Go’s intended state-passing concurrency and idiomatic style.
- How deep it goes
- Defines first-class functions and generic sequence operations, then stops at a pragmatic comparison rather than implementation guidance.
- Examples
- Uses generic sequence operations and Go’s pre-1.18 versus post-1.18 capabilities as contrastive examples.
- What you can do after
- Evaluate functional-style Go against idiomatic Go trade-offs.
Read how Go in Practice, Second Edition explains functional programming →
Julia as a Second Language
Functional programming is a programming paradigm that emphasizes expressions, function composition, and transformations of data with limited mutable state.
- How it is used
- Develops a functional mindset for Julia programming alongside object-oriented design.
- How deep it goes
- Defines core practices and explains a data-transformation pipeline, contrasting it with input mutation.
- Examples
- Uses a snake-case conversion pipeline and contrasting approaches to an encryption service.
- What you can do after
- Evaluate and understand functional and object-oriented approaches to the same programming problem.
Read how Julia as a Second Language explains functional programming →
Python Workout, Second Edition
Functional programming is a programming paradigm that emphasizes composing computations as functions and minimizing mutable state and side effects.
- How it is used
- Uses immutability, short functions, and function composition to make programs more reliable and maintainable.
- How deep it goes
- Explains the rationale for immutability and statelessness, then illustrates transformations with generator expressions and aggregation.
- Examples
- Uses an immutable Person replacement and Zoo queries that filter animals and sum their legs.
- What you can do after
- Apply functional techniques to write shorter functions with fewer state-dependent paths and easier testing.
Read how Python Workout, Second Edition explains functional programming →
Acing the Frontend Interview
Functional programming is a programming paradigm that emphasizes pure functions, immutable data, function composition, and minimized side effects.
- How it is used
- Positions functional programming as an interview-ready approach for writing clean, predictable, modular JavaScript.
- How deep it goes
- Defines pure functions and immutability, practices array transformations, and extends toward currying, pipelines, performance, and architecture.
- Examples
- Uses counter mutation, addition, map transformations, currying, logging wrappers, and functional data-processing pipelines.
- What you can do after
- Apply pure functions and array methods, refactor imperative code, and articulate functional trade-offs during technical interviews.
Read how Acing the Frontend Interview explains functional programming →
Microservices Patterns, Second Edition
Functional-style programming is a programming approach that emphasizes functions with limited side effects and minimizes dependencies on mutable state.
- How it is used
- Supports design for testability by making business logic easier to validate with automated tests.
- How deep it goes
- Connects dependency-free business logic to fast unit tests, without detailing implementation mechanics.
- Examples
- Uses business logic without dependencies and a mock DAO as examples of targets for fast unit tests.
- What you can do after
- Apply the style by isolating business logic from dependencies for fast in-memory unit testing.
Read how Microservices Patterns, Second Edition explains functional programming →
Idiomatic Rust
Functional programming is a programming paradigm that emphasizes composing computations as functions and minimizing mutable state and side effects.
- How it is used
- Frames functional programming as a way to compose declarative functions while minimizing mutation and side effects in Rust.
- How deep it goes
- Defines the paradigm and surveys Rust’s high-level support through closures and iterators, while deferring a deeper treatment.
- Examples
- Uses I/O and local mutation as examples of side effects, and cites JavaScript and TypeScript as common users of closures.
- What you can do after
- Understand how immutability and pure functions support reasoning, testing, reuse, and deterministic behavior.
Also covered in
- Grokking Statistics
- Rust in Action: Systems programming concepts and techniques
- Modern Angular
- Deep Learning with R, Third Edition
- Learn Rust in a Month of Lunches
- Python How-To
- Advanced Algorithms and Data Structures
- Practices of the Python Pro
- Elixir in Action, Third Edition
- Tiny Python Projects: Learn coding and testing with puzzles and games
- The Coder CafeIn early access (MEAP)
- Secrets of the JavaScript Ninja, Third EditionIn early access (MEAP)
What to know first
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
- object-oriented programmingObject-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
- loopA loop is a programming-language control-flow construct that repeatedly executes a block of instructions according to an iteration rule or continuation condition.
- stateState is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions.
Related concepts
- imperative programmingcontrasts with · Imperative programming is a programming paradigm that expresses computation as ordered commands or instructions that direct execution or change state.
- object-oriented programmingcontrasts with · Object-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
- pure functionuses · A pure function is a function whose result depends only on its explicit inputs and whose evaluation has no externally observable side effects.
- functionuses · A function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
- JAXused by · JAX is a Python library for high-performance array computing, with composable transformations for automatic differentiation, compilation, vectorization, and parallelization.
- composabilityuses · Composability is the property of components or operations that allows them to be combined into larger systems or behaviors while retaining their intended properties.
Questions about functional programming
What is functional programming?
Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.
Which Manning books explain functional programming?
Functional Programming in JavaScript, Grokking Simplicity, The Joy of JavaScript, Functional Design and Architecture: Examples in Haskell, Unit Testing Principles, Practices, and Patterns, The Art of Code, Functional Programming in C#, Second Edition, Functional Programming in Scala, Second Edition and 14 more.
What should I know before learning functional programming?
Manning books that teach functional programming usually introduce function, object-oriented programming, loop and state first.
What is the difference between functional programming and imperative programming?
Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects. Imperative programming is a programming paradigm that expresses computation as ordered commands or instructions that direct execution or change state.
What is functional programming also called?
Functional programming is also called functional style, FP or functional paradigm.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.





















