Partial application
Partial 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.
Learn Haskell by Example
Partial function application is the evaluation of a function with fewer arguments than its full arity, producing a function that accepts the remaining arguments.
- How it is used
- Specializes general line-numbering, padding, and missing-value functions by fixing configuration or behavior arguments.
- How deep it goes
- Defines partial application, derives `const True` and its type, and relates concise forms to eta reduction.
- Examples
- Uses `const True`, line-numbering variants, `padLeft` and `padRight`, and `map (maybe "" show)` over `Maybe Int` values.
- What you can do after
- Apply it to create specialized functions from general Haskell functions without duplicating implementations.
Read how Learn Haskell by Example explains partial application →
The Joy of JavaScript
- How it is used
- Builds configurable, composable functions for data transformation, file decoding, property access, and collection processing.
- How deep it goes
- Explains manual currying, closures, automated currying, and arity-sensitive edge cases such as default parameters.
- Examples
- Uses addition, buffer decoding, word counting, transaction property access, multi-property extraction, and mapped collection accessors.
- What you can do after
- Build reusable JavaScript functions by binding configuration now and supplying operational data later.
Read how The Joy of JavaScript explains partial application →
Functional Programming in JavaScript
- How it is used
- Supports modular, reusable JavaScript by specializing general functions into smaller components.
- How deep it goes
- Defines argument binding, contrasts partial application with currying, and supplies an implementation with placeholders.
- Examples
- Uses Lodash loggers, partially applied string methods, URL parsing, and a configurable scheduler.
- What you can do after
- Apply it via Lodash’s _.partial, including placeholder arguments, to create functions with fewer parameters.
Read how Functional Programming in JavaScript explains partial application →
Functional Programming in Scala, Second Edition
Partial application is the creation of a function by supplying some arguments to a function while leaving the remaining arguments to be supplied later.
- How it is used
- Uses higher-order functions and Scala’s type system to constrain implementations.
- How deep it goes
- Derives the only compiling implementation from the return type and function literal, stopping at the basic pattern.
- Examples
- Uses partial1 with a fixed first argument and a two-argument function, alongside curry, uncurry, and compose signatures.
- What you can do after
- Build it from scratch by returning a function that applies the fixed argument and later argument to f.
Read how Functional Programming in Scala, Second Edition explains partial application →
Data Pipelines with Apache Airflow, Second Edition
partial() is an Airflow task-mapping method that specifies operator parameters kept constant across mapped task instances.
- How it is used
- Configures constant operator parameters while Dynamic Task Mapping varies inputs across generated task instances.
- How deep it goes
- Defines the parameter split and demonstrates PythonOperator syntax, but does not explain implementation internals.
- Examples
- Uses mapped addition and movie-review processing driven by fetch_ratings output.
- What you can do after
- Apply it via Airflow Dynamic Task Mapping to generate independently processed tasks from runtime outputs.
Read how Data Pipelines with Apache Airflow, Second Edition explains partial application →
Clojure: The Essential Reference
Partial application is the technique of fixing some arguments of a function to produce another function that accepts the remaining arguments.
- How it is used
- Configures existing functions for later composition, particularly in sequence processing.
- How deep it goes
- Defines deferred arguments, demonstrates arity behavior, and contrasts partial application with explicit currying.
- Examples
- Uses arithmetic, string searching, string construction, collection predicates, request validation, and sequence mapping.
- What you can do after
- Apply partial to build configured functions and compose them with sequence-processing operations.
Read how Clojure: The Essential Reference explains partial application →
Julia as a Second Language
Partial application is a functional programming technique that fixes some arguments of a function to produce a new function requiring fewer arguments.
- How it is used
- Uses fixed arguments to create reusable functions for pipelines and higher-order operations such as map, filter, and reduce.
- How deep it goes
- Defines the technique and implements it with Julia methods and closures, but stops short of runtime or compiler internals.
- Examples
- Demonstrates camel-case conversion, filename filtering, Caesar encryption, and substitution encryption through reusable functions.
- What you can do after
- Apply it via Julia closures and methods to build reusable pipeline stages, predicates, encryptors, and decryptors.
Read how Julia as a Second Language explains partial application →
Fabulous Adventures in Data Structures and Algorithms
Partial application is the creation of a function by binding one or more arguments of another function to particular values.
- How it is used
- Uses bound functions to specialize operations and represent Hughes-list concatenation without immediately performing the work.
- How deep it goes
- Explains binding, currying, captured values, and deferred Hughes-list concatenation through C# listings, but does not quantify performance.
- Examples
- Demonstrates a curried adder, retrieving a bound value with zero, and a Hughes list backed by partially applied concatenation.
- What you can do after
- Apply it via C# delegates to specialize functions and defer concatenation until a Hughes list is converted to a stack.
Read how Fabulous Adventures in Data Structures and Algorithms explains partial application →
Python How-To
A partial function is a callable object created from another callable by pre-filling some of its arguments.
- How it is used
- Simplifies routine calls by localizing arguments shared across functions used in a project.
- How deep it goes
- Demonstrates construction and calling briefly, but stops short of detailed partial-function internals.
- Examples
- Uses repeated statistical-model calls across projects, then localizes model and output-path arguments with functools.partial.
- What you can do after
- Apply it via functools.partial to build readable project-specific callables with frozen arguments.
The Well-Grounded Rubyist, Fourth Edition
Partial function application is a functional programming technique that applies fewer arguments than a function's arity and returns a function accepting the remaining arguments.
- How it is used
- Creates reusable functions by fixing selected arguments while leaving the remaining arguments for later calls.
- How deep it goes
- Explains arity, returned functions, chained calls, grouped arguments, and variadic behavior, while stopping short of implementation internals.
- Examples
- Uses addition, multiple-finding functions, chained calls, grouped calls, variadic summation, and a curried method.
- What you can do after
- Apply it via Ruby's curry method to build specialized functions from lambdas, procs, or methods.
Read how The Well-Grounded Rubyist, Fourth Edition explains partial application →
Related concepts
- functionproduces · A function is a defined operation that maps inputs to outputs and, when implemented as a callable program unit, may also produce effects.
- curryingequivalent to · Currying is the transformation of a function accepting multiple arguments into a sequence of functions that accept arguments incrementally, typically one at a time.
- Q# operationproduces · A Q# operation is a callable Q# construct that can accept parameters, act on qubits, and return a value.
- constused by · const is a standard Haskell function that returns its first argument while ignoring its second argument.
- Hughes listused by · A Hughes list is a functional list representation implemented with a binary tree while exposing linked-list features.
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.