What you will learn in Functional Programming in JavaScript
How to improve your JavaScript programs using functional techniques
Chapter by chapter
Concepts explained in this book
- functional, stateless philosophyA programming paradigm that builds software by composing and transforming functions, typically emphasizing pure functions and immutable data over mutable state and side effects.
- referential transparencyThe property of an expression or function call that can be replaced by its value without changing program behavior because it always yields the same result for the same inputs.
- compositionA sequence of function invocations linked by a shared intermediate value or by staged transformation.
- declarative programmingA programming paradigm that describes what should be done by specifying desired results rather than the step-by-step control flow to achieve them.
- arrow functionAn anonymous function expression, typically used as a value or inline callback.
- curryingA function-transformation technique that converts a function taking multiple arguments into a sequence of functions each taking fewer arguments, often unary functions.
- functionA function is a defined operation that maps inputs to outputs and, when implemented as a callable program unit, may also produce effects.
- pure functionA pure function is a function whose output is determined solely by its explicit inputs and whose evaluation has no externally observable side effects.
- recursionA problem-solving technique in which a process is defined in terms of smaller instances of itself until a base case is reached.
- immutable collectionThe property of data or state not changing after it has been created.
- monadAn abstraction that represents computations with context and provides a way to sequence them while controlling how values and effects propagate.
- IOA monadic abstraction for describing and sequencing input/output or other side-effecting actions as values.
- flatmapFlatMap is an operation that applies a function producing nested collections or computational contexts to each element and combines the resulting contexts into one flattened result.
- reactive programmingA programming paradigm centered on data flows and propagation of change, especially for responding to asynchronous or event-driven updates.
- decompositionDecomposition is the process of dividing a complex whole into smaller constituent parts that can be handled or analyzed separately.
- filteringA function exposed by Lodash as part of its utility API.
- EitherA monadic type that represents a value that can be one of two possibilities, commonly used to encode success or error outcomes.
- liftingThe transformation of a value or operation into a context so it can participate in computations of that context.
- optionA monadic type that represents an optional value, distinguishing presence from absence without using null directly.
- memoizationA technique that caches the results of function calls so repeated calls with the same inputs can reuse prior results instead of recomputing.
- side effectAn externally observable change caused by executing code, such as I/O, mutation, or interaction with shared state.
- observableAn object representing a stream of values or events that observers can subscribe to over time.
- imperative programmingA programming paradigm that specifies computation as a sequence of statements that change program state over time.
- higher-order functionA higher-order function is a function that takes other functions as arguments, returns a function, or both.
- LodashA JavaScript utility library that provides functions for common programming tasks, including collection and object operations.
- lazy evaluationAn evaluation strategy that delays computing an expression until its value is required.
- temporal dependencyA dependency in which one computation must wait for another to complete at a particular time before it can safely proceed.
- callbackA programming pattern in which a function is passed to another operation to be invoked later, often for asynchronous control flow.
- closureA function together with the lexical environment in which it was created, enabling access to captured variables after the outer scope has finished executing.
- scopeScope is the region of program text in which a binding name refers to a particular variable or function declaration.
- pipelineA Ramda function that composes functions from left to right into a new function.
- promiseA JavaScript Promise is an object representing the eventual completion or failure of an asynchronous operation and its resulting value or reason.
- then methodA Promise method that registers callbacks to run when the promise settles and returns a new promise for chaining.
- combinatorA higher-order function that combines other functions to coordinate control flow or transformation in a functional program.
- functorAn abstract container or computational context that supports mapping a function over its contents while preserving its structure.
- mockingA testing technique that replaces external dependencies with controlled stand-ins whose behavior and interactions can be asserted.
- cachingAn intermediary repository that stores previously computed or retrieved values for later reuse.
- rot13A simple substitution cipher that rotates alphabetic characters by 13 positions.
- Blanket.jsA JavaScript code-coverage tool that instruments source code and reports execution coverage.
- JSCheckA JavaScript library for property-based testing that generates random test cases from declared specifications.
- property-based testingA testing approach that checks whether a program satisfies general properties across many generated inputs rather than only fixed example cases.
- safeFindStudentA book-local function name for a safe student lookup that returns a wrapped result.
- getOrElseAn operation that returns the wrapped value when present or a default value otherwise.
- joinA monadic operation that removes one layer of nesting from a monadic structure.
- JustA Maybe case that wraps a defined value.
- LeftThe left-hand case of an Either value, conventionally used to carry failure or error information.
- Maybe.fromNullableA Maybe constructor-like operation that converts a nullable value into a Maybe value.
- NothingA Maybe case that represents the absence of a value or a failure without extra detail.
- orElseAn operation that provides an alternative computation or action when a value is absent or a failure case occurs.
- RightA right-hand Either case that conventionally carries a successful value.
- type constructorAn operation or definition that creates values of a parameterized type.
- type-lifting functionA monadic constructor operation that lifts a plain value into a monadic context.
- code coverageThe proportion of a program’s executable code that is exercised by a test suite or other execution run.
- cyclomatic complexityA software metric that counts the number of linearly independent paths through a program’s control flow.
- instrumentationThe process of inserting tracking code into software so execution behavior can be observed or measured.
- first-class objectA function value that can be assigned, passed as an argument, and returned like other values in a language.
- functions as dataA programming view in which functions are treated as representational artifacts for expressing queries or transformations.
- mental modelAn internal conceptual representation used to understand how a system or program behaves.
- mixinA reusable unit of behavior that can be composed into another type or object without classical inheritance.
- Tree.mapA tree traversal operation that applies a function to each node value while preserving the tree structure.
- preorder traversalA tree traversal strategy that visits a node before recursively visiting its children.
- treeA hierarchical data structure of nodes connected by parent-child relationships with a root.
- runA function that sequentially invokes a chain of functions, passing each result to the next.
- RamdaThe conventional global namespace object through which Ramda exposes its functions.
- QuickCheckA Haskell library for property-based testing that generates random test cases from specifications.
- specificationA formal or informal description of the required behavior or properties of a software system or component.
- WrapperA container type that encapsulates a value so it can be transformed through mapped functions while remaining inaccessible directly.
- fmapA mapping operation for a functor that applies a function to the wrapped value and returns a new functor of the same type.
- functional error handlingA programming approach that represents and propagates failures through composable functional abstractions instead of relying on exceptions and imperative control flow.
- tail-call optimizationA compiler optimization that reuses the current call frame for a function call in tail position instead of creating a new stack frame.
- asynchronous programmingA programming approach in which operations proceed without blocking the current thread while results are delivered later via completion, events, or callbacks.
- callback hellA deeply nested callback structure that is difficult to read, maintain, and extend.
- continuation-passing styleA programming style in which control is made explicit by passing the rest of the computation as a function argument.
- execution context stackA stack of execution-context frames used by JavaScript to manage nested function calls and their associated execution state.
- scope chainThe linked chain of lexical environments used for resolving identifiers from an inner JavaScript execution context outward.
- stackA last-in, first-out data structure in which elements are added and removed from one end called the top.
- QUnitA JavaScript unit testing framework for writing and running tests in the browser or other environments.
- trampoliningA technique for simulating tail recursion by repeatedly invoking thunks or continuations in an iterative loop.
- RxJSA JavaScript library for composing asynchronous and event-based programs using observable sequences.
- immediately invoked function expressionAn immediately invoked function expression is a function expression that is executed as soon as it is defined, typically to create an isolated scope.
- module patternA JavaScript encapsulation pattern that exposes a public API while keeping internal state and helper functions hidden.
- private memberA private variable is a program value that is intentionally inaccessible from outside its defining abstraction.
- comprehensionA concise syntax for producing arrays by combining iteration and filtering expressions.
- address.cityA nested property path that refers to the city field inside an address object.
- Person objectAn object representing a person in the book's examples, with properties such as fullname and address.city.
- function bindingThe technique of associating a function with a specific this value or preset arguments so it can be invoked in a controlled context.
- partial applicationPartial application is the creation of a new function by binding some arguments of an existing function while leaving the remaining arguments to be supplied later.
- programmable commasA style of composing computations so that the sequencing semantics are governed by a monad rather than by explicit separators or control flow.
- generatorA JavaScript function form that can pause and resume execution, yielding a sequence of values over time.
- alt combinatorA combinator that chooses between two alternative computations, returning the first defined result or otherwise the second.
- edge caseAn edge case is an unusual, extreme, or boundary input or condition that may cause behavior different from ordinary cases or reveal a limitation or failure.
- fork combinatorA combinator that sends one input through two functions and combines their results with a third function.
- identity functionA function that returns its argument unchanged.
- seq combinatorA combinator that runs multiple functions in order on the same input value.
- tap combinatorA combinator that applies a function to a value for its side effects and then returns the original value unchanged.
- arityThe number of arguments a function accepts.
- tupleA finite ordered collection of fixed length that groups multiple values into a single composite value.
- type compatibilityThe property that one function’s output type matches another function’s accepted input type.
- iteratorAn iterator is an object or abstraction that provides successive values from a sequence or data source through a traversal protocol.
- eager evaluationEager evaluation is an execution strategy that computes expressions or performs operations immediately rather than deferring them until their results are needed.
- method fusionA functional-programming optimization that combines compatible operations into fewer passes and fewer intermediate data structures.
- try-catch statementA control-flow structure that handles exceptions by enclosing risky code in a try block and handling thrown errors in a catch block.
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.