Finite Functional Programming

• Finite Functional Programming is a paradigm that unifies functional and logic programming by treating predicates as finitely supported functions over pointed sets.
• It introduces explicit finite input-output tables and built-in collection types (List, Bag, Set) that enforce computable operations with static finiteness guarantees.
• The approach supports higher-order functions, aggregation, and table algebra for robust relational queries and graph algorithms while preventing nontermination.

Finite functional programming is a paradigm that unifies the perspectives of functional and logic programming by treating predicates as finitely supported functions and extending their domain to arbitrary pointed sets. This approach enables predicates, relations, weighted functions, and aggregation to be represented as explicit, finite input–output tables and manipulated via higher-order code subject to static guarantees of finiteness. The paradigm has received recent formalization and practical instantiation in languages and type systems designed to guarantee finite support, generalize beyond Boolean-valued relations, and facilitate robust integration of algebraic and logic programming constructs (Arntzenius et al., 28 Apr 2026, Yorgey, 2023).

1. Mathematical and Logical Foundations

Finite functional programming is grounded in the formalism of finitely supported functions and pointed sets. A pointed set $(P, nil_P)$ comprises a carrier set $P$ and a distinguished element $nil_P$ signifying the default (“no information”) value. Given $f: A \to P$, the support is defined as

$$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$

A function is finitely supported iff $|\mathrm{supp}(f)| < \infty$, permitting its representation as an explicit table $$\{\, a \mapsto f(a) \mid a \in \mathrm{supp}(f) \,\}$$, with all other $a$ mapped to $nil_P$.

Datalog, a prototypical logic programming language, can be interpreted as the subcase where $P = bool$ and $P$0. In this case, $P$1 corresponds to the set of finite relations on $P$2. The approach generalizes to any pointed set, such as commutative semirings $P$3, enabling weighted logic programming and aggregations (Arntzenius et al., 28 Apr 2026).

2. Core Language Constructs and Typing

Finite functional programming languages such as Disco (Yorgey, 2023) provide built-in types for finite collections:

• List A: Ordered, finite sequences.
• Bag A: Finite multisets.
• Set A: Finite sets.

These are formalized as inductive (μ-type) definitions: $P$4 and have algebraic data representations. Disco’s type system supports parametric polymorphism, equirecursive types (so that μ-types are equal up to unfolding), and structural subtyping, including covariant subtyping on collections and a diamond of numeric subtypes: $P$5, $P$6, $P$7.

Finite support is statically enforced through type systems that distinguish:

• Ordinary variables: $P$8
• Pointed-set variables: $P$9
• Finitely supported variables: $nil_P$0

Type judgments take the schematic form: $nil_P$1 with $nil_P$2 for ordinary, $nil_P$3 for pointed-set, and $nil_P$4 for finite-support bindings, enforcing finiteness for all computations tracked through $nil_P$5. Key inference rules statically guarantee finite support by design (Arntzenius et al., 28 Apr 2026).

3. Operational Semantics and Manipulation of Finite Collections

Since all collection types are finite, set-theoretic operations (union, intersection, difference, comprehensions) can be fully realized via enumeration. Disco provides operational rules and reduction semantics for finite sets such as:

• Union: For $nil_P$6, $nil_P$7 by enumerating $nil_P$8 and $nil_P$9.
• Intersection: $f: A \to P$0 as $f: A \to P$1 with $f: A \to P$2.
• Set difference: $f: A \to P$3 as $f: A \to P$4 with $f: A \to P$5.
• Comprehension: $f: A \to P$6 evaluated by bounded enumeration.

Combinators for aggregation and matrix operations, e.g.,

$f: A \to P$7

rely on finite supports to guarantee computability and termination (Yorgey, 2023, Arntzenius et al., 28 Apr 2026).

4. Higher-Order Functions, Pointed Maps, and Compositionality

A critical distinction is drawn between point-preserving maps $f: A \to P$8 (where $f: A \to P$9; “code”) and finitely-supported maps $$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$0 (“data”). Point-preserving maps always map default elements to default elements, facilitating higher-order programming without loss of finite support through compositions.

Composition and combination of supports leverage categorical constructs:

• Inner join (smash product $$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$1): Grounds tables left to right, ensuring combined supports remain finite.
• Outer join (direct product $$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$2): Merges supports with default padding.

The collection of finite-map functors $$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$3 forms a graded monad with unit and join induced by table extension and product, preserving the monad laws up to product associativity isomorphisms (Arntzenius et al., 28 Apr 2026).

5. Illustrative Examples

Finite functional programming enables concise representation of relations, predicates, and weighted logic constructs.

Example	Type Signature	Description
Datalog predicate	$$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$4	Finite relation table with $$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$5 as default
Weighted edge map	$$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$6	Table of weighted edges; support as nonzero
Aggregation	$$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$7	Sums weights over support
Matrix multiply	$$\mathrm{supp}(f) = \{\, a \in A \mid f(a) \neq nil_P \,\}.$$8	Multiplies matrices via joins and aggregation

These constructs are illustrated in both (Yorgey, 2023) as concrete Disco programs (e.g., finite relations and converses, map, finite search) and (Arntzenius et al., 28 Apr 2026) as formal table algebra for Datalog and weighted logic programming.

6. Applications, Advantages, and Limitations

Finite functional programming offers a foundation for:

• Datalog/relational queries as first-class values.
• Weighted/probabilistic logic programming (e.g., ProbLog, Dyna) via semiring-valued supports.
• Graph algorithms (reachability, finite enumeration of paths).
• Sparse and dense tensor algebra as special cases of finite map contraction.

Key advantages include a uniform treatment of tables and higher-order functions, static finiteness guarantees for all maps, and extensibility to non-Boolean aggregation and provenance tracking. Compared to infinite-structure functional languages (e.g., Haskell), this model precludes nontermination in set/data operations, ensures computations are well-founded, and aligns more directly with textbook mathematics, especially for the discrete setting.

However, recursion/fixed-point computation and coinductive streams are absent by design. Enforcing static finiteness through type systems necessitates sophisticated type-checking infrastructure (subtyping, equirecursion, relevance typing), and refinement types for encodings such as fixed-size vectors are not inherently supported. Efficient implementation of incremental evaluation, fusion with streaming, and full metatheoretic guarantees (substitution, confluence) remain ongoing research challenges (Arntzenius et al., 28 Apr 2026, Yorgey, 2023).

• "Finite Functional Programming" (Arntzenius et al., 28 Apr 2026)
• "Disco: A Functional Programming Language for Discrete Mathematics" (Yorgey, 2023)