Hubbry Logo
CurryingCurryingMain
Open search
Currying
Community hub
Currying
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Currying
Currying
Currying
View on Wikipedia
from Wikipedia
Not found
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Currying

View on Grokipedia
from Grokipedia
In and , currying is the technique of translating the evaluation of a function that takes multiple arguments into evaluating a of single-argument functions, where each subsequent function is derived from the previous one by fixing an argument. This transformation allows functions to be partially applied, producing new functions that await remaining arguments, and is a of paradigms. The concept traces its origins to early 20th-century , with foundational ideas appearing in Gottlob Frege's work on function notation and composition around 1893, though not explicitly formalized as currying. It was more directly developed by Moses Schönfinkel in his 1924 paper "On the Building Blocks of Mathematical Logic", where he introduced to eliminate bound variables and express multi-argument functions via higher-order single-argument ones. expanded on these ideas in the 1930s through his contributions to and , emphasizing their role in foundational mathematics and computation. The term "currying" itself was coined in 1967 by in his lecture notes Fundamental Concepts in Programming Languages, as a nod to Curry's influential work, despite the eponymous law that the named individual often did not originate the concept. In modern , currying facilitates , composition, and by enabling partial function application—creating specialized functions from general ones without executing the full until all arguments are supplied. Languages such as , ML, and Scala adopt curried functions as the default for multi-argument definitions, treating them as right-associated chains (e.g., f a b c as ((f a) b) c), which supports and higher-order programming. This contrasts with uncurried styles in languages like Python or , where multi-argument functions use tuples or lists, but currying can be emulated for similar benefits. Beyond programming, currying appears in as the currying adjunction between product and exponential categories, linking function spaces to hom-sets.

Overview and Motivation

Core Concept

Currying is a fundamental technique in and for transforming a function that accepts multiple arguments into a sequence of functions, each designed to accept a single argument. In type-theoretic terms, this converts a function f:(X×Y)→Zf: (X \times Y) \to Z into an equivalent function f′:X→(Y→Z)f': X \to (Y \to Z), such that f′(x)(y)=f(x,y)f'(x)(y) = f(x, y) for all x∈Xx \in X and y∈Yy \in Y. This transformation preserves the original function's behavior while restructuring it to facilitate stepwise application and composition. A simple intuitive example illustrates this process: the binary addition function add(x,y)=x+y\text{add}(x, y) = x + y, which takes two numbers and returns their sum, can be curried into add′(x)=λy. x+y\text{add}'(x) = \lambda y.\ x + y. Here, applying add′\text{add}' to an initial argument xx produces a new unary function that adds xx to any subsequent yy, effectively breaking down the computation into nested steps. This approach builds upon unary functions—those with exactly one argument—as the essential primitives, allowing complex multi-argument operations to be expressed through nesting without requiring direct support for multiple inputs in the underlying system.

Practical and Theoretical Motivations

Currying provides significant practical benefits in by enabling , where a function with multiple parameters can be applied to fewer arguments to produce a new function with the remaining parameters. This technique allows developers to create specialized, reusable functions incrementally, enhancing code and reducing repetition. For example, in workflows, a curried function for mapping can be partially applied with a specific transformation (e.g., squaring values), yielding a reusable component that can then be composed into pipelines, such as applying it after a filtering step to process lists efficiently. Such partial applications promote the construction of flexible function chains, making it easier to abstract common operations and adapt functions to varying contexts without rewriting code. In languages like Haskell and OCaml, this leads to more concise and maintainable programs, as functions naturally support higher-order usage and composition, streamlining tasks like event handling or configuration. Theoretically, currying addresses the foundational design of lambda calculus by reducing multi-argument functions to nested unary functions, ensuring all operations fit within a uniform single-argument application model. This simplification maintains the calculus's elegance and completeness, allowing it to express complex computations through abstraction and application alone, without needing primitives for multiple arguments. Furthermore, currying promotes compositionality in function types by facilitating the handling of functions over potentially infinite domains, such as or recursive structures, through sequential application. At a high level, this aligns with the structure of Cartesian closed categories, where currying manifests as a natural between hom-sets, preserving compositional properties for multi-input functions.

Historical Development

Origins in and

The concept of currying first emerged in the work of Moses Schönfinkel, who introduced it in 1924 through his paper "On the Building Blocks of Mathematical Logic," presented earlier in 1920 to the Göttingen Mathematical Society. In this foundational contribution to combinatory logic, Schönfinkel demonstrated how functions of multiple arguments could be reduced to compositions of unary functions, eliminating the need for bound variables in logical expressions and laying the groundwork for variable-free notations in logic. This approach extended earlier ideas in mathematical logic, emphasizing building blocks that transform expressions without explicit quantification. Haskell Curry independently rediscovered and formalized these ideas in the late 1920s and 1930s, significantly advancing through a series of papers and his systematic treatment of the subject. Curry's work, including developments in the foundational aspects of logic via combinators, provided a rigorous framework that built upon Schönfinkel's innovations, though Curry himself acknowledged the priority of Schönfinkel's contributions. Despite this, the technique became known as "currying" in later decades, a that Curry protested in his later years, as it overlooked Schönfinkel's earlier . In Alonzo Church's , developed during the 1930s starting with his 1932 paper "A Set of Postulates for the Foundation of Logic," currying became integral to the system's expressiveness. Church's framework treats functions of multiple arguments as nested abstractions, each taking a single argument, thereby enabling the reduction of complex functional applications to successive unary operations within the calculus's reduction rules. This integration bridged combinatory logic's variable-free style with lambda notation's explicit abstractions, establishing currying as a core mechanism for modeling computation in the theory.

Adoption in Programming Languages

The adoption of currying in programming languages began with early functional influences in the family during the late 1950s and 1960s. , developed by John McCarthy in 1958, pioneered higher-order functions through its abstractions, enabling programmers to treat functions as first-class citizens and manually compose them in a curried manner, which laid foundational groundwork for paradigms. This approach influenced subsequent languages by demonstrating how currying-like could enhance code reusability and abstraction without explicit multi-argument syntax. A key milestone occurred in 1975 with the introduction of Scheme, a dialect designed by Gerald J. Sussman and Guy L. Steele Jr., which standardized support for lexical scoping and higher-order functions via lambda expressions, facilitating curried function definitions as a core feature in its initial specification. Scheme's emphasis on minimalism and purity extended Lisp's legacy, making currying accessible through syntactic constructs like (lambda (x) (lambda (y) ...)), and it became integral to the language's role in teaching functional concepts. In the 1970s, the family of languages, originating with in 1973 under , integrated automatic currying as a standard mechanism, where functions are inherently treated as unary and return new functions upon , simplifying syntax for multi-argument operations. This design choice, evident in languages like (defined in 1983–1997), supported polymorphic by representing function types as chains of arrows (e.g., int -> int -> int), enabling concise declarations without arguments. Currying's role in these systems proved pivotal for , as it aligns with the by ensuring principal types for partially applied functions, reducing ambiguity in polymorphic contexts and facilitating let-polymorphism without explicit annotations. Haskell, emerging in the late 1980s and first released in , elevated currying to a , with all functions implicitly curried and type signatures reflecting nested arrows, such as add :: Int -> Int -> Int, which denotes a function that takes an Int and returns another Int -> Int function. This built directly on ML's foundations but extended it with , making currying essential for higher-kinded types and monadic compositions in the 1990s Haskell reports. In , Haskell's system leverages currying to propagate constraints across nested applications, ensuring decidable unification in the presence of type classes and extensions like GADTs. More recently, incorporated elements facilitating currying through 6 (ES6) in 2015, where arrow functions (e.g., x => y => x + y) and closures enable lightweight manual currying, influencing functional-style programming in without native automatic support. This adaptation, while not altering JavaScript's multi-argument , has promoted curried patterns in libraries like , bridging imperative and functional paradigms in modern applications.

Basic Formalization

Definition via Function Composition

In and , currying provides a formal mechanism to transform a function accepting multiple arguments into a nested sequence of single-argument functions through composition of abstractions. Consider a f:X×Y→Zf: X \times Y \to Z, where XX, YY, and ZZ are sets. The curried form, denoted curry(f)\mathrm{curry}(f), is defined as λx∈X.(λy∈Y.f(x,y)):X→(Y→Z)\lambda x \in X. (\lambda y \in Y. f(x, y)): X \to (Y \to Z). This leverages by treating the outer abstraction as a function that maps an element x∈Xx \in X to an inner function, which in turn maps y∈Yy \in Y to the original output f(x,y)f(x, y). The evaluation of the curried function proceeds via successive applications: curry(f)(x)(y)≡f(x,y)\mathrm{curry}(f)(x)(y) \equiv f(x, y), illustrating how composition restores the multi-argument behavior. The inverse operation, known as uncurrying, reverses this process; for a function g:X→(Y→Z)g: X \to (Y \to Z), the uncurried form is λ(x,y).g(x)(y):X×Y→Z\lambda (x, y). g(x)(y): X \times Y \to Z. This duality ensures that and uncurrying form a pair of mutually inverse transformations. In , currying establishes a between the space of multi-argument functions and their curried counterparts, meaning there is a one-to-one mapping between functions of type X×Y→ZX \times Y \to Z and functions of type X→(Y→Z)X \to (Y \to Z). This preserves the structure and semantics of the original function, enabling equivalent expressiveness in typed settings without loss of . The property holds due to the inherent between the respective function spaces in Cartesian closed categories underlying simply typed systems, though here it is grounded in basic type assignments.

Examples in Set Theory and Function Spaces

In set theory, currying provides a canonical , or , between the set of all functions from the Cartesian product X×YX \times Y to a set ZZ, denoted \Hom(X×Y,Z)\Hom(X \times Y, Z), and the set of all functions from XX to the function set \Hom(Y,Z)\Hom(Y, Z), denoted \Hom(X,\Hom(Y,Z))\Hom(X, \Hom(Y, Z)). This maps a function f:X×Y→Zf: X \times Y \to Z to a function f~:X→\Hom(Y,Z)\tilde{f}: X \to \Hom(Y, Z) defined by f~(x)(y)=f(x,y)\tilde{f}(x)(y) = f(x, y) for all x∈Xx \in X and y∈Yy \in Y, with the inverse mapping f~\tilde{f} back to ff via f(x,y)=f~(x)(y)f(x, y) = \tilde{f}(x)(y). The function set \Hom(Y,Z)\Hom(Y, Z) is standardly denoted ZYZ^Y in , where the superscript YY indicates the domain of the functions and the base ZZ their , reflecting the exponential-like structure of function spaces. For instance, in the , this notation captures the ∣Z∣∣Y∣|Z|^{|Y|} of the set of functions, emphasizing the set-theoretic foundation of currying as a structural equivalence. A concrete example arises with real numbers, where the multiplication function \mul:R×R→R\mul: \mathbb{R} \times \mathbb{R} \to \mathbb{R} defined by \mul(x,y)=xy\mul(x, y) = x y belongs to \Hom(R×R,R)\Hom(\mathbb{R} \times \mathbb{R}, \mathbb{R}), or equivalently RR×R\mathbb{R}^{\mathbb{R} \times \mathbb{R}}. Currying transforms it into \mul′:R→(R→R)\mul': \mathbb{R} \to (\mathbb{R} \to \mathbb{R}), or \mul′:R→RR\mul': \mathbb{R} \to \mathbb{R}^\mathbb{R}, such that \mul′(x)=λy. xy\mul'(x) = \lambda y.\, x y. Applying this yields \mul′(2)=λy. 2y\mul'(2) = \lambda y.\, 2 y, the linear function multiplying its input by 2, illustrating how currying decomposes binary operations into unary ones within function spaces.

Advanced Mathematical Contexts

Category Theory Perspective

In category theory, currying is formalized as a natural isomorphism arising from the structure of Cartesian closed categories. Specifically, a category C\mathcal{C} is Cartesian closed if it has all finite products and, for every pair of objects B,C∈CB, C \in \mathcal{C}, an exponential object CBC^B exists such that there is a natural bijection hom⁡C(A×B,C)≅hom⁡C(A,CB)\hom_{\mathcal{C}}(A \times B, C) \cong \hom_{\mathcal{C}}(A, C^B) for all A∈CA \in \mathcal{C}, where ×\times denotes the Cartesian product and hom⁡C\hom_{\mathcal{C}} the hom-set of morphisms. This isomorphism defines the currying operation: given a morphism f:A×B→Cf: A \times B \to C, its curry \curry(f):A→CB\curry(f): A \to C^B satisfies \eval∘(\curry(f)×\idB)=f\eval \circ (\curry(f) \times \id_B) = f, with \eval:CB×B→C\eval: C^B \times B \to C the canonical evaluation morphism. Dually, uncurrying provides the inverse. This structure captures currying as the counit of the adjunction between the product functor −×B⊣(−)B-\times B \dashv (-)^B, ensuring that function spaces behave as expected in higher-order settings. The naturality of the currying means that for any morphisms α:A′→A\alpha: A' \to A, β:B′→B\beta: B' \to B, and γ:C→C′\gamma: C \to C' in C\mathcal{C}, the following commutes: \begin{tikzcd} \hom(A' \times B', C) \arrow[r, "\cong"] \arrow[d, "\hom(\alpha \times \beta, \gamma)"] & \hom(A', C^{B'}) \arrow[d, "\hom(\alpha, \gamma \circ (-)^{\beta})"] \\ \hom(A \times B, C') \arrow[r, "\cong"] & \hom(A, C'^B) \end{tikzcd} This property guarantees that currying respects composition and substitution, allowing seamless integration into categories and higher categorical constructions. In particular, it enables the definition of curried functors and transformations within the category of categories, facilitating abstract reasoning about computational and logical systems. In the category of sets Set\mathbf{Set}, currying corresponds directly to the familiar function set isomorphism: for sets A,B,CA, B, C, a function f:A×B→Cf: A \times B \to C yields \curry(f):A→(CB)\curry(f): A \to (C^B) where \curry(f)(a)(b)=f(a,b)\curry(f)(a)(b) = f(a, b), with CBC^B the set of all functions from BB to CC. This exemplifies how the categorical definition recovers concrete function currying in everyday mathematics. In programming language theory, the exponential CBC^B relates to type constructors for function types, such as B→CB \to C in typed lambda calculi, where currying transforms multi-argument functions into nested single-argument ones, underpinning the type systems of languages like Haskell.

Type Theory and Lambda Calculi

In the , multi-argument function types are formalized using curried arrow types, where a type such as α→α→α\alpha \to \alpha \to \alpha denotes the nested structure α→(α→α)\alpha \to (\alpha \to \alpha), representing a function that accepts an of type α\alpha and yields a function from α\alpha to α\alpha. This curried representation ensures by composing single-argument functions, aligning with the syntax of abstractions λxα.M\lambda x^\alpha . M and applications MNM N, where types are checked recursively along the arrow chain. The polymorphic extension in , the second-order , preserves this currying mechanism while incorporating over types. For example, a polymorphic multi-argument type ∀α.α→α→α\forall \alpha . \alpha \to \alpha \to \alpha curries to ∀α.α→(α→α)\forall \alpha . \alpha \to (\alpha \to \alpha), with type abstraction Λα.M\Lambda \alpha . M enabling generic functions that operate uniformly across type instantiations M[A/α]M [A / \alpha]. This structure maintains the expressive power of polymorphism, as curried forms allow type variables to scope over nested arrows without altering the underlying parametricity properties. Beta-reduction in curried typed lambda calculi proceeds by substituting arguments into abstractions, as in (λxτ.M)N→βM[N/x](\lambda x^\tau . M) N \to_\beta M[N/x] for simply typed terms or (Λα.M)A→βM[A/α](\Lambda \alpha . M) A \to_\beta M[A/\alpha] for polymorphic ones, with applications to curried forms reducing stepwise through nested beta steps. Normalization for curried terms is equivalent to that of uncurried forms (modeled using product types τ1×τ2\tau_1 \times \tau_2), as both exhibit strong normalization in and , meaning every reduction sequence terminates in a normal form, with the Church-Rosser property ensuring regardless of reduction order. In type theories with dependent types, such as , currying generalizes to iterated Pi-types, where the dependent function type Πx:A.B(x)\Pi x : A . B(x) serves as the primitive for functions whose depends on the domain value. A multi-dependent-argument type curries as nested Pi-types, and implications curry accordingly, transforming Πx:A.B(x)→Πx:A.(B(x)→C)\Pi x : A . B(x) \to \Pi x : A . (B(x) \to C) to reflect the dependent structure while preserving typing derivations.

Specialized Frameworks

Domain Theory

In domain theory, currying establishes an between the spaces of continuous functions [D×E→F][D \times E \to F] and [D→[E→F]][D \to [E \to F]] over complete partial orders (CPOs), where DD, EE, and FF are CPOs equipped with Scott-continuous functions as morphisms. This , mediated by the curry operation, maps a g:D×E→Fg: D \times E \to F to a λd.(λe.g(d,e))\lambda d. (\lambda e. g(d, e)), preserving the partial order and ensuring the inverse (uncurry) reconstructs the original. Crucially, this maintains the CPO structure, including the existence and uniqueness of least fixed points for continuous endofunctions, as the curry and uncurry maps are themselves Scott-continuous and thus preserve directed suprema and fixed-point semantics. The preservation of Scott-continuity under currying is essential for of recursive definitions in programming languages. A function f:D×E→Ff: D \times E \to F is Scott-continuous if it preserves suprema of directed sets in each argument separately, and the curried form curry(f):D→[E→F]\text{curry}(f): D \to [E \to F] inherits this property, ensuring that fixed points of recursive equations remain well-defined and computable via from element ⊥\bot. This is particularly relevant for the Y-combinator, whose in a reflexive domain is the least fixed point of the functional Φf=λx.f(xx)\Phi f = \lambda x. f (x x), where allows higher-order to be modeled as a continuous endomap on the , facilitating the approximation of infinite computations by finite ones. In powerdomains, currying extends to model probabilistic and non-deterministic computations by constructing isomorphic function spaces over lifted domains, preserving continuity.

Logic and Algebraic Topology

In , currying aligns with the rule of implication introduction under the Curry-Howard , which establishes a correspondence between proofs in and terms in the simply-typed . Specifically, a proof of an implication A→BA \to B from an assumption AA is represented by a λxA.tB\lambda x^A . t^B, transforming a multi-argument function into a sequence of unary functions, where the type A→BA \to B denotes the from AA to BB. This , first observed in Haskell Curry's work on and formalized by William in an unpublished 1969 manuscript, underscores how currying encodes logical implication as functional in systems. In such systems, curried forms facilitate the constructive interpretation of implications without relying on classical excluded middle, ensuring proofs remain computationally meaningful. In , currying extends to (HoTT), where types are interpreted as topological spaces and identities as paths, integrating with homotopical structures. Here, curried functions model mappings in ∞-categories, with path spaces—representing equalities between terms—arising as curried representations of dependent function types; for instance, a path from f(a)f(a) to g(a)g(a) in a type family C(x)C(x) over a:Aa : A corresponds to a curried map p:∏x:A(f(x)=g(x))p : \prod_{x:A} (f(x) = g(x)). This perspective, developed in univalent foundations, treats currying as a continuous operation preserving homotopy equivalences, allowing proofs to capture higher-dimensional paths and homotopies in synthetic homotopy theory. Unlike classical type theory, HoTT's currying supports identity types as inductive families, enabling the study of topological invariants through type-theoretic constructions. An illustrative example appears in theory, where classifiers facilitate curried predicates within the internal logic of a . The classifier Ω\Omega classifies monomorphisms via characteristic morphisms, allowing predicates on objects AA to be represented as curried maps A→ΩA \to \Omega, equivalent to of AA; for binary relations, this curries to A→(B→Ω)A \to (B \to \Omega), mirroring implication in the internal . This framework, pioneered by in the late through his development of elementary topoi as Cartesian closed categories with classifiers, provides a categorical semantics for where currying arises from the exponential adjunction. Lawvere's innovations, building on sheaf theory and quantifiers, enabled topoi to model geometric and logical structures uniformly, with curried predicates central to diagonal arguments and fixed-point theorems in these settings.

Applications and Implementations

In Functional Programming

In , functions are implicitly curried, meaning a function declared to take multiple arguments is treated as a chain of single-argument functions, each returning another function until the final result. This design, as specified in the Haskell 2010 language report, allows for seamless where supplying fewer arguments than expected yields a new function awaiting the remaining ones. For instance, the addition operator (+) has the type Num a => a -> a -> a, equivalent to Num a => a -> (a -> a), enabling expressions like (+ 5) to produce a function that adds 5 to its input. This currying facilitates point-free programming, a style where functions are defined without explicitly naming their arguments, relying instead on composition and higher-order functions for conciseness and abstraction. The composition operator (.), defined as (f . g) x = f (g x), exemplifies this, with type (b -> c) -> (a -> b) -> (a -> c). A point-free definition might rewrite addOne x = (+) 1 x simply as addOne = (+ 1), eliminating variable references while preserving semantics. More advanced point-free expressions, such as composing addition into higher-order operations, demonstrate how currying supports modular code; for example, (.) . (+) partially applies the composition operator to (+) , yielding a function that composes any unary function with addition in a curried manner. This style, enabled by currying, promotes reusable combinators like foldr or custom pipelines, reducing boilerplate in functional compositions. In languages without native currying like , developers implement it manually using arrow functions or methods like bind(), transforming multi-argument functions into nested single-argument ones. For example, a curried can be defined as const add = x => y => x + y;, allowing such as const addTwo = add(2); addTwo(3) which computes 5. This approach leverages 's first-class functions to mimic functional paradigms. Arrow functions provide concise syntax for such nesting, avoiding the verbosity of traditional function expressions while maintaining lexical scoping. Currying offers key benefits in by enabling the creation and use of combinators, such as compose utilities that chain transformations without intermediate variables. For instance, a compose function compose(f, g) = x => f(g(x)) can itself be curried to compose(f)(g), facilitating point-free pipelines in supported languages. It also aids handling in partial applications by allowing type-checked or domain-specific functions to be pre-configured, reducing runtime surprises in higher-order contexts—though this requires careful argument ordering to avoid mismatches. In non-native environments like Python, currying is achieved via utilities such as functools.partial or third-party libraries like Toolz's curry, but introduces overhead from additional function wrappers and closures, potentially increasing execution time in tight loops compared to direct multi-argument calls.

python

from functools import partial def add(x, y): return x + y curried_add = partial(add, 5) # Partial application, but full currying requires custom implementation result = curried_add(3) # Returns 8, with wrapper overhead

from functools import partial def add(x, y): return x + y curried_add = partial(add, 5) # Partial application, but full currying requires custom implementation result = curried_add(3) # Returns 8, with wrapper overhead

In Mathematical Modeling

In mathematical modeling, currying serves as a technique to parameterize functions, transforming multi-argument relations into nested single-argument functions, which aids in structuring complex models for analysis and computation. This transformation is particularly useful in optimization problems, where a L:Θ×X→RL: \Theta \times \mathcal{X} \to \mathbb{R}, representing the discrepancy between model predictions and observations, can be curried to L^:Θ→(X→R)\hat{L}: \Theta \to (\mathcal{X} \to \mathbb{R}), defined by L^(θ)(x)=L(θ,x)\hat{L}(\theta)(x) = L(\theta, x). Such parameterization allows for efficient of model across datasets by fixing parameters θ\theta and varying inputs xx, enabling the computation of gradients ∇θL^(θ)\nabla_\theta \hat{L}(\theta) that drive iterative optimization algorithms like in statistical models. This approach is evident in quantum mechanical modeling, such as the Hartree-Fock method, where currying the energy functional facilitates optimization over orbital parameters while treating electron configurations as subsequent inputs. In the context of dynamical systems, currying supports the composition of flows generated by differential equations, treating vector fields as higher-order functions. Consider a system governed by y˙=V(t,y)\dot{y} = V(t, y), where V:R×Rn→RnV: \mathbb{R} \times \mathbb{R}^n \to \mathbb{R}^n is the ; currying yields V^:R→(Rn→Rn)\hat{V}: \mathbb{R} \to (\mathbb{R}^n \to \mathbb{R}^n), with V^(t)(y)=V(t,y)\hat{V}(t)(y) = V(t, y), allowing the flow ϕt:Rn→Rn\phi_t: \mathbb{R}^n \to \mathbb{R}^n to be viewed as a parameterized family of maps that compose sequentially over time intervals. This structure enables modular analysis of system trajectories, such as in synchronous dynamical systems on graphs, where curried functions maintain bounded in-degrees for complexity assessments. By enabling such compositions, currying facilitates the study of stability and bifurcations without explicit multi-variable dependencies, as seen in dynamical systems derived from doctrines. A concrete application appears in , where currying joint distributions produces conditional distributions essential for modeling dependencies. For random variables XX and YY with joint density p:X×Y→[0,∞)p: \mathcal{X} \times \mathcal{Y} \to [0, \infty), currying gives p^:X→(Y→[0,∞))\hat{p}: \mathcal{X} \to (\mathcal{Y} \to [0, \infty)), where p^(x)(y)=p(x,y)\hat{p}(x)(y) = p(x, y), and the conditional p(y∣x)=p^(x)(y)/∫p^(x)(y′) dy′p(y \mid x) = \hat{p}(x)(y) / \int \hat{p}(x)(y') \, dy' follows naturally as a normalized section. This functional perspective underpins Bayesian updating and relational reasoning in probabilistic models, allowing conditionals to be treated as maps from evidence to posterior densities, as utilized in metric-based probabilistic frameworks. In Markov processes, such curried representations align chance interpretations of probabilities, supporting simulations and mass-based semantics for transition kernels.

Partial Function Application

Partial function application is a technique in where some, but not all, arguments of a multi-argument function are supplied in advance, yielding a new function that accepts the remaining arguments. This process creates a specialized version of the original function without altering its underlying type or , allowing the resulting function to still accept multiple arguments as needed. For instance, given a binary addition function add(x, y) = x + y, partial application can fix the first argument to produce add5 = add(5, ·), where add5(y) = 5 + y for any y. In contrast to currying, which systematically transforms a multi-argument function into a chain of unary functions (e.g., add(x)(y) = x + y), partial application operates on the function as defined and does not enforce a unary interface at each step. Currying inherently enables by design, as applying fewer than all arguments in a curried function naturally yields intermediate unary functions. However, in languages without built-in currying, partial application requires explicit support, preserving the original function's multi-argument capability while fixing specific inputs. Practical implementations highlight this distinction. In Python, which uses uncurried functions, the functools.partial utility enables without currying: from functools import partial; add = [lambda](/page/Lambda) x, y: x + y; add5 = partial(add, 5), resulting in add5(3) == 8. This differs from explicit currying in Python, which would involve nested to create a chain of unary functions. Similarly, in Scheme, combinators like cut and cute from SRFI-26 facilitate , including sectioning variants that fix arguments from the left (cut) or right (cute), such as (cut + 5 <>) for add5.

Higher-Order Functions and Closures

Currying transforms a function that accepts multiple arguments into a sequence of functions, each accepting a single argument, thereby inherently producing higher-order functions—those that either take functions as arguments or return functions as results. In the lambda calculus, this process aligns with the treatment of functions as first-class citizens, where application is left-associative, allowing expressions like f(x)(y)f(x)(y) to denote the application of the result of f(x)f(x) to yy. A canonical example is the map operation, which can be expressed in curried form as map:(a→b)→(→)\text{map} : (a \to b) \to ( \to ), where it first accepts a function from type aa to bb and returns a new function that applies it to each element of a list of type , yielding a list of type . This structure enables partial application, such as map(+3)\text{map}(+3), which produces a function incrementing list elements by 3, illustrating how currying facilitates the creation of specialized higher-order abstractions without explicit function definitions. In languages supporting lexical scoping, such as Scheme, curried functions leverage closures to capture the environment in which they are defined, including let-bound variables, allowing access to non-local state across multiple invocations. A closure in this context binds a function to the values of free variables from its surrounding scope, preserving them even after the defining scope exits. For instance, consider a curried function defined within a :

scheme

(let ((base 4)) (define (expt-curried) (lambda (exp) (* base (expt base (- exp 1))))) (expt-curried 2)) ; Returns 16, using the captured base

(let ((base 4)) (define (expt-curried) (lambda (exp) (* base (expt base (- exp 1))))) (expt-curried 2)) ; Returns 16, using the captured base

Here, the inner captures the let-bound base, enabling the curried function to maintain state specific to its creation environment without relying on global variables. This mechanism is fundamental in Scheme's of first-class functions, where closures encapsulate both code and data for modular, reusable components. The interplay between currying and closures extends to imperative languages like JavaScript, where it enables the construction of stateful functional constructs without polluting the global namespace, often via immediately invoked function expressions (IIFEs). An IIFE creates a closure that captures local variables, returning curried functions that maintain private state across calls. For example, a curried adder can be wrapped in an IIFE to simulate a counter:

javascript

const makeCounter = (function(initial) { let count = initial; return function(increment) { count += increment; return count; }; })(0); makeCounter(5); // Returns 5 makeCounter(3); // Returns 8, retaining previous state

const makeCounter = (function(initial) { let count = initial; return function(increment) { count += increment; return count; }; })(0); makeCounter(5); // Returns 5 makeCounter(3); // Returns 8, retaining previous state

This pattern uses the closure to bind count to the IIFE's scope, allowing the returned curried function to update and access it persistently, thus achieving encapsulation and in functional style. Such techniques underscore how currying, combined with closures, supports higher-order programming paradigms in diverse environments by facilitating environment capture and .

References

  1. https://plato.stanford.edu/entries/logic-combinatory/notes.html
  2. https://courses.cs.cornell.edu/cs3110/2021sp/textbook/hop/currying.html
  3. https://www.johndcook.com/blog/2018/08/11/currying/
  4. https://content.wolfram.com/sites/43/2020/12/Schonfinkel-OnTheBuildingBlocksOfMathematicalLogic.pdf
  5. https://www.schemeworkshop.org/2013/papers/HemannCurrying2013.pdf
  6. https://cs.brown.edu/courses/cs017/content/lectures/23curry-record-bigO-types-trees-reason.pdf
  7. https://www.haskell.org/haskellwiki/currying
  8. https://personal.utdallas.edu/~hamlen/cs6371sp25/slides-lambda.pdf
  9. https://ncatlab.org/nlab/show/currying
  10. https://plato.stanford.edu/entries/lambda-calculus/
  11. https://xavierleroy.org/publi/higher-order-uncurrying.pdf
  12. https://mhamilton.net/files/chl.pdf
  13. https://www.rbjones.com/rbjpub/logic/cl/index.htm
  14. https://iep.utm.edu/haskell-brooks-curry/
  15. https://writings.stephenwolfram.com/2020/12/where-did-combinators-come-from-hunting-the-story-of-moses-schonfinkel/
  16. https://iep.utm.edu/lambda-calculi/
  17. https://dl.acm.org/doi/10.1007/s11023-017-9432-7
  18. https://dl.acm.org/doi/10.1145/72551.72554
  19. https://www.scheme.com/tspl3/preface.html
  20. https://www.scheme.com/tspl4/preface.html
  21. https://dl.acm.org/doi/10.1145/3386336
  22. https://smlfamily.github.io/history/SML-history.pdf
  23. https://people.cs.uchicago.edu/~gkuan/pubs/esop07-kmf.pdf
  24. https://www.haskell.org/onlinereport/haskell98/
  25. https://theory.stanford.edu/~aiken/publications/papers/popl91.pdf
  26. https://javascript.info/currying-partials
  27. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
  28. https://home.ttic.edu/~dreyer/course/papers/barendregt.pdf
  29. https://math.ucr.edu/home/baez/rosetta.pdf
  30. https://www.maths.ox.ac.uk/system/files/attachments/SetTheoryHT18.pdf
  31. http://www.cs.man.ac.uk/~schalk/msc/cccs.pdf
  32. https://www.mathstat.dal.ca/~selinger/papers/lambdanotes-2up.pdf
  33. https://www.cs.cmu.edu/~fp/courses/15317-f00/handouts/dependent.pdf
  34. https://www.cs.famaf.unc.edu.ar/~mpagano/cursos/dominios/libros/abramsky-jung-domain-theory.pdf
  35. https://homepage.divms.uiowa.edu/~slonnegr/plf/Book/Chapter10.pdf
  36. https://disi.unitn.it/~bernardi/RSISE11/Papers/curry-howard.pdf
  37. https://www.cs.cmu.edu/~rwh/courses/clogic/www/handouts/curry-howard.pdf
  38. https://www.cs.uoregon.edu/research/summerschool/summer14/rwh_notes/hott-book.pdf
  39. https://ncatlab.org/nlab/show/subobject+classifier
  40. https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-260003.3
  41. https://www.haskell.org/haskellwiki/Pointfree
  42. https://www.haskell.org/onlinereport/haskell2010/haskellch9.html#x16-1710009
  43. https://docs.python.org/3/library/functools.html
  44. https://arxiv.org/pdf/2403.15024
  45. https://arxiv.org/pdf/2312.08385
  46. https://arxiv.org/pdf/2208.12173
  47. https://arxiv.org/pdf/1807.05091
  48. https://arxiv.org/pdf/2506.10377
  49. https://cs.wellesley.edu/~cs251/f19/slides/ml-curry.pdf
  50. https://elmcraft.org/learn/currying-vs-partial-application
  51. https://peps.python.org/pep-0309/
  52. http://www.phyast.pitt.edu/~micheles/scheme/scheme14.html
  53. https://homepage.cs.uiowa.edu/~slonnegr/plf/Book/Chapter5.pdf
  54. https://learnyouahaskell.com/higher-order-functions
  55. https://www.cs.rhodes.edu/~kirlinp/rhodes/proglang/s13/360-lect9-slides.pdf
  56. https://courses.cs.umbc.edu/331/spring13/notes/scheme/environments_in_scheme_6x.pdf
  57. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Closures
Add your contribution
Related Hubs
User Avatar
No comments yet.