Pure Borrow: Linear Haskell Meets Rust-Style Borrowing

Abstract: A promising approach to unifying functional and imperative programming paradigms is to localize mutation using linear or affine types. Haskell, a purely functional language, was recently extended with linear types by Bernardy et al., named Linear Haskell. However, it remained unknown whether such a pure language could safely support non-local \emph{borrowing} in the style of Rust, where each borrower can be freely split and dropped without direct communication of ownership back to the lender. We answer this question affirmatively by \emph{Pure Borrow}, a novel framework that realizes Rust-style borrowing in Linear Haskell with purity. Notably, it features parallel state mutation with affine mutable references inside pure computation, unlike the IO and ST monads and existing Linear Haskell APIs. It also enjoys purity, lazy evaluation, first-class polymorphism and leak freedom, unlike Rust. We implement Pure Borrow simply as a library in Linear Haskell and demonstrate its power with a case study in parallel computing. We formalize the core of Pure Borrow and build a metatheory that works toward establishing safety, leak freedom and confluence, with a new, history-based model of borrowing.

• The paper introduces Pure Borrow, a framework extending Linear Haskell with Rust-style borrowing to enable non-local, parallel-safe mutation.
• It employs affine mutable references and a novel BO monad to ensure leak freedom, deterministic outcomes, and support for reborrowing.
• Empirical results demonstrate that its work-stealing quicksort achieves competitive performance compared to state-of-the-art Haskell sorting algorithms.

Pure Borrow: Achieving Rust-Style Borrowing in Pure Linear Haskell

Introduction and Context

The paper "Pure Borrow: Linear Haskell Meets Rust-Style Borrowing" (2604.15290) introduces Pure Borrow, a framework that extends Linear Haskell with Rust-style borrowing. The work synthesizes fine-grained affine resource management, as epitomized by Rust's borrow checker, with the purity and lazy evaluation central to Haskell. This integration addresses a longstanding open question: Can pure, lazy functional programming safely incorporate Rust's powerful non-local borrowing pattern, including affine borrowers that can be split and dropped independently of their lenders?

Traditionally, Haskell's approach to localized mutation centers around the ST monad and Linear Haskell. Both encapsulate stateful operations within syntactic or type-based scopes but diverge in their support for parallelism, leak freedom, and expressiveness. However, Linear Haskell’s prior APIs—while supporting safe, deterministic mutation and concurrency—mandate direct threading of ownership and lack Rust-style non-locality and ergonomic borrowing semantics. Pure Borrow overcomes these expressive limitations, permitting parallel, pure, and leak-free mutation of affine references with Rust-like borrowing and reborrowing mechanisms, all as a type-level library without requiring compiler modifications.

Foundations: Linear Types, Affinity, and Borrowing

Pure Borrow builds on the theoretical foundation of linear and affine types, motivated by ensuring resources are used at most once (linearity) or up to once (affinity). Haskell’s recent extension with linear types introduces the linear arrow $a \multimap b$, ensuring that the argument is consumed precisely once. This enables the safe introduction of mutability without global side-effects, preserving confluence and program reasoning properties.

Rust, in contrast, utilizes affine types and a sophisticated, mostly-automated region discipline. Each borrower obtains temporary affine access to a resource, which may be split, duplicated, and dropped—ownership of the resource is eventually returned to the (possibly distant) lender via lifetime tracking, rather than explicit program communication. This non-local reclamation is central to both Rust’s expressivity and soundness.

Pure Borrow’s Semantics and Core Abstractions

Pure Borrow introduces a new monad, the BO monad ($\text{BO}^\alpha$), parameterized by a lifetime $\alpha$, that internalizes affine stateful computations—a direct analog to Rust's lifetimes. Its core novel abstractions are as follows:

• Affine Mutable Reference: $\text{Mut}^\alpha~a$ is an affine, borrowable, and splittable mutable reference living within lifetime $\alpha$.
• Lender: $\text{Lend}^\alpha~a$ is a first-class lender, unique in that it can be programmatically manipulated—unlike in Rust, where lenders are implicit.
• Shared Borrower: $\text{Share}^\alpha~a$ enables unrestricted copying and parallel reading subject to affine constraints.
• Primitives: borrow, reclaim, share, and reborrowing enable canonical Rust-like ownership, reclamation, sharing, and reborrowing, respectively.
• Rank-2 Polymorphism: Operations like runBO are rank-2 polymorphic over lifetimes, ensuring safe encapsulation and leak-freedom analogous to runST.

The critical expressive advance is that Pure Borrow supports non-local, affine, and parallel-safe mutation on pure data in Haskell without IO/ST monads and without explicit ownership threading. This is achieved without trading off leak-freedom, confluence, or purity. Borrowers can be safely split, dropped, or reborrowed for shorter lifetimes; after the lifetime ends, ownership is non-locally returned to the lender. This is illustrated in a direct analogy to Rust’s model:

Figure 1: Rust-style borrowing in Pure Borrow, with affine borrowers (depicted by Ferris) that can be split, dropped, and reclaimed non-locally over their lifetime.

Parallel Mutation and Reborrowing

A salient property of Pure Borrow is the ability to perform parallel, pure mutation via affine references, something impossible with prior localized state in Haskell (e.g., the ST monad). Each affine borrower can be split (e.g., via splitAt) into disjoint references, which may then be updated in parallel via parBO, the parallel composition operator for the BO monad. Safety is statically guaranteed by linear typing: disjointness is established via borrow splitting, ensuring race-freedom and determinism.

Furthermore, Pure Borrow supports reborrowing, where a mutable reference can be reborrowed for a strictly shorter lifetime, mirroring Rust's sub-lifetime discipline. This supports advanced patterns such as borrowing through temporarily aliased references and safe in-place transformations in divide-and-conquer algorithms (e.g., parallel quicksort).

An illustration of this is provided in the context of a naїve parallel quicksort over mutable vectors:

Figure 2: High-level illustration and code for a naїve parallel quicksort utilizing parBO and affine borrower splits, facilitating parallel in-place updates with safe reclamation.

The general work-stealing API, also expressible using Pure Borrow, enables more sophisticated divide-and-conquer scheduling:

Figure 3: API for work-stealing parallelism, demonstrating how parallel tasks can safely mutate disjoint sections of data with statically guaranteed separation.

Safety, Purity, Leak Freedom, and Metatheory

Pure Borrow’s design is accompanied by a formal metatheory establishing safety, confluence, leak freedom, and a path toward full behavioral purity. Most notably:

• Purity Guarantee: All mutations via Pure Borrow are made inside pure contexts; outcomes are independent of scheduling orderings and always deterministic.
• Leak Freedom: Linear types prevent unsound resource retention (e.g., via reference cycles), an issue not generally resolved in affine-only systems like Rust.
• Parallelism: Expressly stronger than Haskell’s ST monad, Pure Borrow safely supports parallel executions as all side effects are compartmentalized via the lifetime and affine/linear discipline.
• Metatheory: The paper presents a type-directed bisimulation between a mutative semantics and a functional "denotational" semantics. It introduces a history-based model: all borrower-side mutations are logged in histories associated with lifetime tokens, which are then used to restore the correct state to lenders upon reclamation. This technique ensures non-locality does not break purity or result in resource loss.

Numerical and Empirical Results

The framework is implemented strictly as a Haskell library, constructing all primitives from existing Linear Haskell features and quantifier-polymorphic APIs. The authors demonstrate the expressiveness with parallel quicksort implementations (naїve and work-stealing), benchmarking both against the industrial-strength vector-algorithms package’s sequential introsort.

Their empirical findings show that the work-stealing quicksort via Pure Borrow achieves better runtime performance than the naïve approach and, in several configurations, competitive with state-of-the-art Haskell introsort in both time and space usage. Importantly, all mutation remains pure and leak-free.

Contrasts and Implications

The paper makes strong claims that set it apart from prior approaches:

• First-class lenders: Pure Borrow generalizes Rust's implicit lenders, allowing them as first-class values, opening doors to more dynamic and general borrowing patterns.
• Support for non-lexical lifetimes: While the default combinators implement lexically scoped lifetimes, the framework exposes manual lifetime tokens for encoding non-lexical scopes—a notable step toward capturing the full generality of Rust's lifetime discipline.
• Leak-freedom and purity: Pure Borrow is rigorously leak-free and pure by construction, addressing theoretical and practical limitations of affine-only systems (e.g., the "Leakpocalypse" in Rust due to reference-counted cycles).
• No compiler modification: All expressivity and safety are achieved at the library level in GHC 9.10+, requiring no special runtime or language changes.

In contrast with related work—such as destination passing, region-passing monads, and prior linear/borrowed type systems for functional languages—Pure Borrow provides a higher degree of non-locality, compositionality, and ergonomic expressivity, notably with support for parallel mutation, reborrowing, and compositional affine splitting.

Practical and Theoretical Implications

Practically, Pure Borrow enables safe, idiomatic, and deterministic parallel mutation in pure Haskell code, with leak-freedom and first-class composition of borrowing and aliasing patterns. It provides a direct proof-of-concept for implementing Rust-style resource management atop pure functional languages, hinting at library-level solutions to ergonomic affine resource handling even in current Haskell compilers.

Theoretically, the history-based model for non-local mutation reclamation represents a substantial step toward semantic soundness for mixed linear-affine-pure calculi. The approach can serve as a template for integrating borrowing with higher-order, lazily evaluated, and polymorphic languages and may influence future language and type system design, especially in the space of safe parallelism, fine-grained state encapsulation, and verified resource management.

Limitations and Future Directions

Some advanced Rust patterns—such as partially moved or conditionally borrowed data (e.g., via match on enums)—are not yet supported in Pure Borrow, largely due to their requirement for tight coupling of patterns and borrowing. The model does not provide fully-automated borrow checking as Rust does, instead giving manual tokens for lifetime management. Integration with reference counting, full generality of non-lexical lifetimes, and highest-performance runtime remain open areas.

Future research directions include: automation of borrow checking and lifetime inference; richer resource polymorphism; extension to algebraic effects and compositional effect handling; more powerful parallel schedulers; and a fully machine-checked semantic model providing complete contextual equivalence results.

Conclusion

Pure Borrow delivers a compelling, compositional solution to reconciling Rust-style affine borrowing with pure, lazy, polymorphic functional programming. It demonstrates, with formal metatheory and empirical evidence, that the hallmark benefits of Rust’s borrow semantics—parallel safe mutation, non-local affine drops, and leak prevention—can be reconciled with purity, lazy evaluation, and high-level reasoning. This work both deepens the theoretical understanding of resource management in functional settings and provides practical tools and patterns for efficient, safe, parallel, and pure programming in Haskell and similar languages.