Currying
Currying is the transformation of a function accepting multiple arguments into a sequence of functions that accept arguments incrementally, typically one at a time.
The Joy of JavaScript
A technique that transforms a function of multiple arguments into a sequence of functions each taking a single argument.
- How it is used
- Adapts multi-argument functions into configurable steps that fit function-composition pipelines.
- How deep it goes
- Defines stepwise application, works through manual and helper-based currying, and flags an arity caveat; reviews closures without treating them in depth.
- Examples
- Uses nested addition, configurable buffer decoding, property access, object hashing, and curried array mapping.
- What you can do after
- Build it from scratch with nested functions or a curry helper, then configure functions for composition.
Functional Programming in JavaScript
A function-transformation technique that converts a function taking multiple arguments into a sequence of functions each taking fewer arguments, often unary functions.
- How it is used
- Uses currying to preconfigure dependencies and reduce functions to unary steps for functional pipelines.
- How deep it goes
- Defines deferred curried evaluation, builds a two-argument helper, and examines its execution-context stack overhead.
- Examples
- Demonstrates type checking, student lookup, configurable logging, DOM output, and a nested-loop addition benchmark.
- What you can do after
- Apply it via R.curry or a manual helper to create reusable, partially configured JavaScript functions.
Read how Functional Programming in JavaScript explains currying →
Learn Haskell by Example
curry is a Haskell function that converts a function taking a pair into a function taking two arguments.
- How it is used
- Uses curried and uncurried functions to turn command-line options into composable CSV transformations.
- How deep it goes
- Defines currying and its dual, then demonstrates tuple adaptation with `uncurry`; it stops short of deeper implementation details.
- Examples
- Demonstrates `f = \x -> \y -> ...`, `uncurry slice`, optional intervals, and composed CSV operations.
- What you can do after
- Apply currying and uncurrying in Haskell to adapt function shapes and compose argument-driven transformations.
Functional Programming in Scala, Second Edition
Currying is the transformation of a function taking multiple arguments into a sequence of functions each taking one argument.
- How it is used
- Uses function transformation to expose partial application and motivate higher-order functions.
- How deep it goes
- Explains the type shape and relates it to partial application, while leaving implementation as an exercise.
- Examples
- Uses a two-argument Scala function, a partially applied function, and a carrot-for-apple-and-banana analogy.
- What you can do after
- Practice implementing curry and uncurry from their Scala type signatures.
Read how Functional Programming in Scala, Second Edition explains currying →
F# in Action: A Revised Edition of Get Programming with F#
A curried function is a function represented as a sequence of single-argument functions, allowing arguments to be supplied incrementally.
- How it is used
- Uses single-argument functions to inject stable values early and supply remaining values later.
- How deep it goes
- Explains staged application, signatures, partial application, and practical benefits without descending into formal functional-programming theory.
- Examples
- Demonstrates arithmetic specialization with addFive and domain modeling with a reusable email sender.
- What you can do after
- Apply it via F# to create reusable specialized functions and call multi-argument functions incrementally or all at once.
Read how F# in Action: A Revised Edition of Get Programming with F# explains currying →
The Well-Grounded Rubyist, Fourth Edition
Currying is a functional programming technique that transforms a function of multiple arguments into a sequence of functions that can be evaluated incrementally.
- How it is used
- Creates reusable functions by supplying some arguments now and delaying the remaining computation until later.
- How deep it goes
- Explains arity, staged calls, partial application, and mixed argument groups, while stopping short of implementation internals.
- Examples
- Demonstrates addition, staged three-argument calls, variadic summation, method currying, and reusable array filtering.
- What you can do after
- Apply Ruby's curry method to build specialized functions from general Procs, lambdas, or methods.
Read how The Well-Grounded Rubyist, Fourth Edition explains currying →
Clojure: The Essential Reference
Currying is the transformation of a function of multiple arguments into a chain of functions that each accept a single argument.
- How it is used
- Clarifies how deferred arguments support composable function APIs in Clojure.
- How deep it goes
- Defines nested invocation, contrasts partial application, and stops short of compiler-level currying implementation.
- Examples
- Uses equivalent four-argument addition functions with progressively nested single-argument returns.
- What you can do after
- Apply currying by expressing multi-argument calls as nested single-argument functions, or choose partial for idiomatic Clojure composition.
Read how Clojure: The Essential Reference explains currying →
Related concepts
- higher-order functioncontrasts with · A higher-order function is a function that accepts functions as arguments, returns functions as results, or both.
- functionuses · A function is a callable program unit that performs an operation, may accept inputs, and can produce a result or side effect.
- partial applicationequivalent to · 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.
- functional, stateless philosophykind of · 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.
- Lodashused by · Lodash is a JavaScript utility library providing modular functions for common operations on arrays, collections, objects, strings, functions, and other values.
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.