# Pure Borrow: Linear Haskell Meets Rust-Style Borrowing

**URL:** <https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975>\
**Category:** Show and Tell\
**Created:** [April 23, 2026, 12:48pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975 "2026-04-23T12:48:17Z")\
**Posts on this page:** 15\
**Page:** 1

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 23, 2026, 12:48pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/1 "2026-04-23T12:48:17Z")

</div>

**TL;DR** You can now use Rust-style mutable and shared borrows in Linear Haskell, within `ST`-like linear monad, `BO`, with pure, type-safe, and leak-freedom support of mutation and concurrency! It comes with flexible feature of multiple aliasing of shared borrows, delimiting lifetime regions, etc!

We are really pleased to announce the acceptance of our work, _Pure Borrow_, at PLDI 2026 🎉

- Paper (Extended Version): [[2604.15290] Pure Borrow: Linear Haskell Meets Rust-Style Borrowing](https://arxiv.org/abs/2604.15290)
- Implementation: [GitHub - SoftwareFoundationGroupAtKyotoU/pure-borrow: Pure Borrow: Linear Haskell Meets Rust-Style Borrowing · GitHub](https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow)
- PLDI Program: [Pure Borrow: Linear Haskell Meets Rust-Style Borrowing (PLDI 2026 - PLDI Research Papers) - PLDI 2026](https://pldi26.sigplan.org/details/pldi-2026-papers/16/Pure-Borrow-Linear-Haskell-Meets-Rust-Style-Borrowing)

This is joint work of Yusuke Matsushita, the first author of “[RustHorn: CHC-based Verification for Rust Programs](https://arxiv.org/abs/2002.09002)”, and I.  
I am mainly in charge of the implementation and Yusuke-san does the theoretical works.

## Background

Linear Haskell, i.e. today’s GHC with `LinearTypes` extension enabled, introduces the new arrow type `a %1 -> b`, which reads "If the application is consumed exactly once, then so is the argument of type `a`.  
In particular, it ensures that there is exactly one owner of the resource bound by the function, and this allows us fine-grained resource management and do destructive updates purely.  
The guarantee of the uniqueness of the owner, or absence of alias, typically should allow a pure and deterministic _parallel_ computation.  
This intuition once lead me to the exploration around the pure and parallel divide-and-conquer algorithm on arrays:

> [@Experience Report: Linear Haskell enables Pure, Parallel, and In-place Fast Fourier Transformation](https://discourse.haskell.org/t/experience-report-linear-haskell-enables-pure-parallel-and-in-place-fast-fourier-transformation/8256):
>
> Motivation Since I have read the [Linearly Quantified Types paper](https://arxiv.org/abs/2103.06127) and [Arnaud’s articles on Linear Constraints](https://www.tweag.io/blog/2023-01-26-linear-constraints-freeze/), I’ve been very excited about how we will be able to use linear constraints to formulate borrowing subslices of arrays within Linear Haskell. Linear Constraint is not available in GHC today, as the [Linear constraints proposal](https://github.com/ghc-proposals/ghc-proposals/pull/621) by Arnaud has just been discussed (I :+1:ed a lot smile): Although it is not available in the current GHC, we should still be able to simulate linear constrain…

Meanwhile, Yusuke started Pure Borrow project and just stumbled upon my article above.  
He reached out to me and we started to work together 🙂

## What’s New in Pure Borrow?

In Pure Borrow, we bring the notion of Rust-style _borrows_ into the Linear Haskell realm.

To see the flavour, we give a simple parallel quicksort implementation in Pure Borrow:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/98634b264018fbe45f4be6fb34494e727eac4820/src/Data/Vector/Mutable/Linear/Borrow.hs#L273-L293>

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/98634b264018fbe45f4be6fb34494e727eac4820/src/Data/Vector/Mutable/Linear/Borrow.hs#L295-L323>

`BO α` is the monad that plays the central role in Pure Borrow.  
It is a linear-variant of the `ST`-monad, with each parameter `α` corresponds to the _lifetime_ where the resources are borrowed for. It can also be viewed as a linear generalization of monadic regions, but for pure computation.

Note that `parIf` is a simple combinator to run the given two computations in parallel with `parBO` primtive when the condition is met, and runs sequentially otherwise.  
This is safe and pure, thanks to Pure Borrow’s support of disjoint division of borrows.

`Mut α x` is the _mutable borrow_ of a resource of type `x` - in particular, it is always bound and consumed linearly.  
Indeed, it is a special case of more general ‘Borrow’ type:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure/Internal.hs#L226-L228>

There is one more borrow type: `Share`:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure/Internal.hs#L269-L271>

So, what’s the difference between mutable and shared borrows?  
First, both borrows a resource from its unique `Lend`er:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure/Internal.hs#L294-L296>

A `Mut α a` retains the _exclusive_ permission to mutate the borrowed resource of type `a` during the lifetime `α`.  
Together with `Lend α a`, it can be introduced by `borrow`ing a bare resource:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure/Internal.hs#L301-L302>

Note that they are bound linearly, making sure there is only one `Mut α`.

On the other hand, `Share α a` can be aliased nonrestrictedly, i.e. they can be bound for any number of times, in the absence of `Mut α a`.  
The primal introduction rule of `Share α a` is `share`ing it:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure/Internal.hs#L311-L312>

Note that `Ur a` is defined as follows, which means that value wrapped inside `Ur` can be used for as many times as possible (i.e. nonlinearly) after pattern matching on it:

```haskell
data Ur a where Ur :: a %'Many -> Ur a

```

As `share` consumes `Mut α a` linearly, it assumes there is no `Mut α a` left after the `shar`ing.  
In this way, Pure Borrow allows both localized pure destructive updates and multiply-aliased shared read access to the resources.

Further, both types of borrow can be divided into pieces.  
One such example is `splitAt` function used in the quicksort example above:

```haskell
splitAt ::
  Int %1 ->
  Borrow bk α (Vector a) %1 -> 
  (Borrow bk α (Vector a), Borrow bk α (Vector a))

```

Some immutable types (e.g. primitive types such as `Int` or `Bool`, and the recursive type with those elements like `Maybe Char` or `[Either Int (Bool, String)]`, etc.) can be copied into the direct value:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure/Internal.hs#L484-L485>

We also have a variant for random access to arrays:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Data/Vector/Mutable/Linear/Borrow.hs#L259-L260>

Which is implemented in terms of `get` on an array and `copy`:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Data/Vector/Mutable/Linear/Borrow.hs#L182-L184>

But, both `copyAt` and `copy` are expecting `Share α a` as its argument.  
How can we apply it to `Mut α a` things?  
Here, the concept of sublifetime comes into a play, as in the implementation of `copyAtMut`:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Data/Vector/Mutable/Linear/Borrow.hs#L262-L263>

Where, `sharing` combinator delimits the ephemeral sublifetime and share the given mutable borrow:

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure.hs#L257-L266>

It is implemented in terms of `share` and `reborrow` (and `reborrow` in terms of more low-level primitives):

> <https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/blob/fb11ce9138f228dbf3d1f0de7832ba80e8c4fdcd/src/Control/Monad/Borrow/Pure.hs#L307-L310>

Aside from the quicksort example, here is a simple example demonstrating a mixed use of mutable and shared borrows:

```haskell
example :: (Int, Int, Int, [Int])
example = linearly \lin -> DataFlow.do
  (lin, lin') <- dup lin
  vec <- fromList [0, 1, 2] lin
  runBO lin' \ @α -> Control.do
    let !(mvec, lend) = borrowLinearOnly vec
    mvec <- modify 0 (+ 3) mvec
    ((i0, i2), mvec) <- sharing mvec \svec -> Control.do -- (*)
      Ur i0 <- copyAt 0 svec
      Ur i2 <- copyAt 2 svec
      Control.pure (i0, i2)
    mvec <- modify 2 (+ 5) mvec -- (a)
    mvec <- modify 0 (* 4) mvec -- (b)
    let !(Ur svec) = share mvec
    Ur n <- copyAt 0 svec
    pureAfter (i0, i2, n, unur $ toList (reclaim @α lend))

```

This just allocates a mutable array with elements `[0, 1, 2]`, multiply the first element, inspect first and third intermediate values, modify the third and first again, then retrieve the final value of the first value.  
This evaluates to `(3, 2, 12, [12, 1, 7])` as expected.

> ⚠ **Use GHC 9.12.3 or higher when using REPL** (EDITED)  
> If you want to use REPL to evaluate the above code, please use GHC 9.12.3 - GHC 9.10.3 and 9.12.2 contains a bug that results in segfaults.  
> (Once we considered the behaviour is our correctness bug, but @romes kindly pointing it out it was the bug in GHCi \<9.12.2 and he fixed it in 9.12.3 onward. Thank you @romes!)

The `sharing` in the line `(*)` delimits the sublifetime, and share the contents of `mvec` temporarily for that lifetime.  
Further note that, although we thread through mutable share `mvec` manually (i.e. pass and given back by each function call on `mvec`), we don’t have to thread through shared borrow `svec`s and can call multiple times and read it for multiple times.  
After the sublifetime ends, the original `mvec` is returned and the process proceeds.  
Note that `svec` is bound nonlinearly, we do not need to return the value or consuming it explicitly.

We can go further. Now that mutation in (a) and (b) are on the disjoint parts, we can do it parallelly, by replacing lines (a) and (b) as follows:

```haskell
    mvec <- reborrowing_ mvec \mvec -> Control.do
      let !(mvec1, mvec2) = LV.splitAt 2 mvec
      consume Control.<$> 
        LV.modify 0 (+ 5) mvec2 `parBO` LV.modify 0 (* 4) mvec1

```

This time, the mutable borrow `mvec` is reborrowed into the sublifetime, then divided into two pieces.  
We then modify each pieces _in parallel_ using `parBO` combinator, and discard the returned mutable borrows by calling `consume` combinator on the returned value.  
In this way, we can discard the mutable borrows amidst in the sublifetime without worrying about leaking.

## Shout out for Linear Constraints

Our API makes extensive use of many permission tokens; we need `Linearly` token to ensure the safety of allocation, `End α` token to run the finalization after the lifetime ends, and, even though it doesn’t manifest in the high-level APIs, we need the unique `Now α` linear token for each lifetime `α` to ensure the uniqueness of the lifetime.  
Manually threading them is somewhat cumbersome - and we are really missing for Linear Constraints to ease such handle token management!

> <https://github.com/ghc-proposals/ghc-proposals/pull/621>
>
> Adds a linear fat arrow \`%1 =\>\` this is meant to greatly improve the ergonomics …of some of the APIs using linear types (it tends to apply to APIs based on typestate or related to mutation).
> 
> \[Rendered\](https://github.com/tweag/ghc-proposals/blob/linear-constraints/proposals/0621-linear-constraints.rst).
> 
> There are quite a bit of interactions to consider, let me know if I forgot (or misrepresent!) anything. The alternatives section is rather large, with variants in the design space that may be worth exploring. Don't hesitate to peruse and argue from one variant or other.

Indeed, the permission tokens cover all three types of (non-)linear constraints being proposed:

1. `End α` is a (nonlinear) constraint, which can just be expressed as an ordinary typeclass.
2. `Linearly` is a _duplicable_ linear constraint, which is one of the motivating examples of original Linear Constraints.
3. `Now α` is a _non-duplicable_ linear constraint.

Indeed, `End α` is already made a typeclass in our actual implementation (we didn’t do so in the paper to avoid complication).  
Then, why not for `Linearly` and `Now α`? In this sense, we think our Pure Borrow can be yet another motivating application of Linear Constraints.  
Also, it must be interesting to pursue the possibility to combine Pure Borrow and the permission model a la Linear Constraints paper.

If you feel the same, please 👍 to the Linear Constraints proposal above!

## Conclusions

The paper and implementation also comes with a more sophisticated work-stealing-based quicksort example.  
I’m also re-implementing e-graphs algorithms using Pure Borrow in the repository below:

> **[GitHub - konn/tamagoh](https://github.com/konn/tamagoh)**
>
> Contribute to konn/tamagoh development by creating an account on GitHub.

Although `tamagoh` is not so performant yet, it contains much more involved use cases of Pure Borrow, so you can grasp the taste of Pure Borrow. It also contains experiments around new interfaces for more involvd borrow division and effectful cloning.

The latter half of the paper discusses the theoretical foundation, and sketches the proof of the type safety, purity and leak-freedom of Pure Borrow.  
Although it is not spelled out rigorously, we believe our work bring new insights into this area.

If curious, please read our paper and implementation. Happy Linear Haskelling, and perhaps see you guys in Boulder!

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 23, 2026, 1:33pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/2 "2026-04-23T13:33:10Z")

</div>

… And now I think it might be also good to show the flavour of work-stealing version implementation of quicksort. Here it is:

```haskell
qsortDC' ::
  (Ord a, Copyable a) =>
  -- | Threshold for the length of vector to switch to sequential sort.
  Int ->
  DivideConquer α Pair (LV.Vector a)
qsortDC' thresh =
  DivideConquer
    { divide = \vs ->
        case LV.size vs of
          (Ur n, v)
            | n <= 1 ->
                v `lseq` Control.pure Done
            | n <= thresh ->
                Done Control.<$ LV.qsort 0 v
            | otherwise -> Control.do
                let i = n `quot` 2
                (Ur pivot, v) <- LV.copyAtMut i v
                (lo, hi) <- LV.divide pivot v 0 n
                Control.pure $ Continue $ Pair lo hi
    }

```

It is just a rewritten version of `qsort` in the post, but now defined in terms of `DivideConquer` datatype:

```hs
data DivideConquer α t a = DivideConquer
  { divide :: forall β. (α >= β) => Mut β a %1 -> BO β (Result β t a)
  }

data Result β t a = Done | Continue (t (Mut β a))

```

That is, it just encodes the divide-and-conquer nature within general API, using `BO`-monad inside each step.  
Actual computation can now be done by calling `divideAndConquer` combinator on it:

```hs
qsortDC ::
  (RandomGen g, Ord a, Copyable a, α >= β) =>
  -- | The # of workers.
  Int ->
  -- | Threshold for the length of vector to switch to sequential sort.
  Int ->
  g ->
  Mut α (LV.Vector a) %1 ->
  BO β (Mut α (LV.Vector a))
qsortDC nwork thresh = divideAndConquer nwork (qsortDC' thresh)

divideAndConquer ::
  forall α β t a g.
  (RandomGen g, Data.Traversable t, Consumable (t ()), α >= β) =>
  -- | The # of workers.
  Int ->
  DivideConquer α t a ->
  g ->
  Mut α a %1 ->
  BO β (Mut α a)

```

Under the hood, `divideAndConquer` uses some unsafe constructs, such as concurrent queues, but it hides its implementational detail behind the `BO`-based API, and user can describe their divide-and-conquer algorithm purely with `BO`.  
Although the scheduler logic of `divideAndConquer` still has lot of room of improvements, but it seems quite promising example of applicability of Pure Borrow 🙂

---

<div class="post-metadata">

**Author:** ![L0neGamer](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/l0negamer/32/4536_2.png) [@L0neGamer](https://discourse.haskell.org/u/L0neGamer)\
**Post date:** [April 23, 2026, 1:53pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/3 "2026-04-23T13:53:34Z")

</div>

As a Haskeller, I’ve always been interested in the guarantees that Rust has with regards to data control and flow, and since Linear Types I’ve been excited to see where we could go next.

This post is an excellent demonstration of a potential future for this style, and while I don’t think I’ve got any use case for it in the near future, I hope to find one!

Out of interest, do you think that Pure Borrow could have performance benefits, or is the focus on safety which allows us to go faster?

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 23, 2026, 2:02pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/4 "2026-04-23T14:02:42Z")

</div>

> This post is an excellent demonstration of a potential future for this style, and while I don’t think I’ve got any use case for it in the near future, I hope to find one!

Thanks! We are really encouraged by your comment 👍 🙏

> Out of interest, do you think that Pure Borrow could have performance benefits, or is the focus on safety which allows us to go faster?

Good question! The current primal focus of Pure Borrow is on the purity and safety, I think there are many cases where Pure Borrow can also contribute to the performance, just as with `ST`-monads. Pure Borrow morally enjoys all the feature provided by `ST`-monad, including pure mutable reference and mutable vectors. With the help from linear types, Pure Borrows has parallelism in addition, and borrows allow us fine-grained R/W permission management. In other words, Pure Borrow would expand the range of the fast destructive programs that can be written as a pure function. In this sense, Pure Borrow can contribute the performant programming in Haskell, I think 🙂

---

<div class="post-metadata">

**Author:** ![ashokkimmel](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/ashokkimmel/32/5111_2.png) [@ashokkimmel](https://discourse.haskell.org/u/ashokkimmel)\
**Post date:** [April 23, 2026, 10:01pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/5 "2026-04-23T22:01:46Z")

</div>

Is it on `hackage` anywhere?

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 23, 2026, 10:12pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/6 "2026-04-23T22:12:51Z")

</div>

We definitely plan the release after the fixing the bug with GHCi. So stay tuned!

---

<div class="post-metadata">

**Author:** ![romes](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/romes/32/2912_2.png) [@romes](https://discourse.haskell.org/u/romes)\
**Post date:** [April 24, 2026, 1:51pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/7 "2026-04-24T13:51:25Z")

</div>

This is very cool! I’ll read carefully soon.

> [@konn](#):
>
> Although the Pure Borrow programs work fine after the _compilation_, we are observing that some vector programs with Pure Borrow (involving `copyAt` especially) segfaults when _interpreted_ inside GHCi and HLS Eval Plugin.  
> We are working on this problem, so please be patient and please compile your Pure Borrow program to check the output meanwhile

I think I’ve fixed this bug with linear types in GHCi. It should be fixed in 9.14 and 9.12.3.  
Here are some references:

- [Launch program via GHCi support and questions on linearity · Issue #5 · alt-romes/ghengin · GitHub](https://github.com/alt-romes/ghengin/issues/5#issuecomment-3524251234)
- [Segfault with GHCi 9.12.2 and Linear Types (#26565) · Issues · Glasgow Haskell Compiler / GHC · GitLab](https://gitlab.haskell.org/ghc/ghc/-/issues/26565#note_645783)

Hope that helps!

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 24, 2026, 3:23pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/8 "2026-04-24T15:23:16Z")

</div>

> This is very cool! I’ll read carefully soon.

Thanks! Your comments always encourages me 🙂

> I think I’ve fixed this bug with linear types in GHCi. It should be fixed in 9.14 and 9.12.3.

Wow, I am not aware of that - indeed, I tested GHCi repl only with GHC 9.10.3 and 9.12.2.  
And the code now runs successfully with GHC 9.12.3! Thank you for pointing it out, I’ve just edited the mentioned note accordingly 😍  
So, I think we can prepare for the Hackage release soon!

---

<div class="post-metadata">

**Author:** ![ymat](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/ymat/32/5581_2.png) [@ymat](https://discourse.haskell.org/u/ymat)\
**Post date:** [April 24, 2026, 6:32pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/9 "2026-04-24T18:32:51Z")

</div>

@konn Thanks for the announcement!

Hello! I am Yusuke Matsushita [https://shiatsumat.github.io/](https://shiatsumat.github.io/), the lead author of the Pure Borrow paper.

I love both Haskell and Rust. I learned Haskell in high school, which led me to become a PL researcher. I started my career with Rust research, but I had long wished to contribute to Haskell.

So I am delighted to publish this work, which shows a new connection between the two languages. I hope you enjoy it. Happy Haskelling!

---

<div class="post-metadata">

**Author:** ![ashokkimmel](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/ashokkimmel/32/5111_2.png) [@ashokkimmel](https://discourse.haskell.org/u/ashokkimmel)\
**Post date:** [April 24, 2026, 8:22pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/10 "2026-04-24T20:22:29Z")

</div>

Note that GHC 9.12.3 has a different unrelated bug, so you might want to check with 9.14.1 as it’s probably the only supported version that works for you.

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 25, 2026, 2:46am UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/11 "2026-04-25T02:46:29Z")

</div>

Thanks! Indeed, we’ve already checked against both 9.12. **4** and 9.14.1, both of them worked fine, both compiled and interpreted. Anyway, as far as [our tsest suite tells](https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/actions/runs/24897841551), GHC 9.10.2+ works fine if used compiled, so we don’t worry too much about the supported version ranges.

---

<div class="post-metadata">

**Author:** ![ashokkimmel](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/ashokkimmel/32/5111_2.png) [@ashokkimmel](https://discourse.haskell.org/u/ashokkimmel)\
**Post date:** [April 28, 2026, 12:21pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/12 "2026-04-28T12:21:05Z")

</div>

What is the hackage release date?

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 28, 2026, 12:38pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/13 "2026-04-28T12:38:20Z")

</div>

No particular date in our mind, but I expect within a few weeks. Stay tuned! 🙏

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [April 28, 2026, 1:54pm UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/14 "2026-04-28T13:54:53Z")

</div>

For those who are curious: we are finalising our implementation for the Hackage release in this PR for past few days: [Preparation for Hackage relase by konn · Pull Request #10 · SoftwareFoundationGroupAtKyotoU/pure-borrow · GitHub](https://github.com/SoftwareFoundationGroupAtKyotoU/pure-borrow/pull/10) . We are not idling 🙂

---

<div class="post-metadata">

**Author:** ![konn](https://sea2.discourse-cdn.com/flex002/user_avatar/discourse.haskell.org/konn/32/1420_2.png) [@konn](https://discourse.haskell.org/u/konn)\
**Post date:** [May 5, 2026, 12:26am UTC](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975/15 "2026-05-05T00:26:30Z")

</div>

At long last, we’ve just made the first Hackage release 🎉

> [@\[ANN\] pure-borrow-0.0.0.0](https://discourse.haskell.org/t/ann-pure-borrow-0-0-0-0/14037):
>
> We are pleased to announce the first release of [Pure Borrow: Linear Haskell Meets Rust-Style Borrowing](https://discourse.haskell.org/t/pure-borrow-linear-haskell-meets-rust-style-borrowing/13975) tada Although the implementation is in somewhat usable stage, but it is still under heavy development. See the previous post on Discourse for the detailed explanation. This release covers API described in [our original paper](https://arxiv.org/abs/2604.15290), plus some experimental feature like record borrow splitting or generalized reborrows. Feeedbacks are always welcome! Happy Linear Haskelling! lollipop

> **[pure-borrow](https://hackage.haskell.org/package/pure-borrow-0.0.0.0)**
>
> Rust-style borrowing in Linear Haskell with purity