Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/fizruk/free-foil

Efficient Type-Safe Capture-Avoiding Substitution for Free (Scoped Monads).
https://github.com/fizruk/free-foil

abstract-syntax haskell scala type-safe

Last synced: 26 days ago
JSON representation

Efficient Type-Safe Capture-Avoiding Substitution for Free (Scoped Monads).

Host: GitHub
URL: https://github.com/fizruk/free-foil
Owner: fizruk
License: bsd-3-clause
Created: 2023-10-23T13:36:12.000Z (about 1 year ago)
Default Branch: main
Last Pushed: 2024-08-23T20:42:00.000Z (3 months ago)
Last Synced: 2024-09-29T17:41:49.244Z (about 1 month ago)
Topics: abstract-syntax, haskell, scala, type-safe
Language: Haskell
Homepage: https://fizruk.github.io/free-foil/haddock/
Size: 11.3 MB
Stars: 6
Watchers: 1
Forks: 0
Open Issues: 10
Metadata Files:
- Readme: README.md
- License: LICENSE

Awesome Lists containing this project

README

# Free Foil

[![Release](https://img.shields.io/github/v/release/fizruk/free-foil.svg)](https://github.com/fizruk/free-foil/releases/latest)
[![`free-foil` on Hackage](https://img.shields.io/hackage/v/free-foil)](http://hackage.haskell.org/package/free-foil)
[![`free-foil` on Stackage Nightly](https://stackage.org/package/free-foil/badge/nightly)](http://stackage.org/package/free-foil)
[![`free-foil` on Stackage LTS](https://stackage.org/package/free-foil/badge/lts)](http://stackage.org/package/free-foil)

[![Haskell (build, test, haddock)](https://github.com/fizruk/free-foil/actions/workflows/haskell.yml/badge.svg)](https://github.com/fizruk/free-foil/actions/workflows/haskell.yml)
[![Haddock]()](https://fizruk.github.io/free-foil/haddock/)

Generating Efficient and Scope-Safe Abstract Syntax with Free (Scoped) Monads and Template Haskell (with a partial port to Scala).

## About

This project provides an implementation of the efficient scope-safe representation
for syntax with binders (think λ-abstraction, let-binding, for-loop, etc.).
The underlying representation is based on the IFL 2022 paper by Maclaurin, Radul, and Paszke [«The Foil: Capture-Avoiding Substitution With No Sharp Edges»](https://doi.org/10.1145/3587216.3587224)[^1]. This project extends the foil with patterns, as well as two
techniques for free generation of the foil. The details are presented in the paper [«Free Foil: Generating Efficient and Scope-Safe Abstract Syntax»](https://arxiv.org/abs/2405.16384)[^2]. Also see the [slides from the ICCQ 2024 presentation](https://fizruk.github.io/files/iccq-2024-free-foil-slides.pdf) (also [video](https://youtu.be/06gudJKXpkk?si=FbR03r-bngdZUdlf)).

In brief, following the paper:

1. We introduce [`CoSinkable`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil.html#t:CoSinkable) typeclass to generalize `NameBinder`s to more complex patterns.
2. We provide Template Haskell machinery to generate the proper scope-safe AST definitions as well as conversion functions, and helpers for patterns. This approach works particularly well with the code generated by tools like [BNFC](https://bnfc.digitalgrammars.com) or [`BNFC-meta`](https://hackage.haskell.org/package/BNFC-meta).
3. We define a variant of free scoped monads[^3] with the foil instead of nested data types of Bird and Paterson. This approach allows implementing certain functions once for a large class of languages with binders. Here we implement only substitution, but more involved algorithms, such as generic higher-order preunification[^3] should be possible.

Additionally, we implement:

1. Template Haskell generation for the free foil.
2. Generalized support for patterns using `withPattern` method (currently in `CoSinkable`).
3. Generic α-equivalence for the free foil and α-equivalence support for patterns using `UnifiablePattern` typeclass.
4. Generic conversion functions for the free foil.

In addition to this repository, we have benchmarks for the foil and the free foil against each other and other implementation of λ-calculus.
See [KarinaTyulebaeva/lambda-n-ways](https://github.com/KarinaTyulebaeva/lambda-n-ways), a fork of Stephanie Weirich's benchmark suite ([sweirich/lambda-n-ways](https://github.com/sweirich/lambda-n-ways)).

## Project structure

### Haskell

The Haskell code is organized into two packages as follows:

#### `free-foil` package

- [`Control.Monad.Foil`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil.html) provides basic definitions for the foil[^1], including safe scopes, sinking, name maps, and scope constraints. In addition to the standard definitions, we contribute

- [`CoSinkable`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil.html#t:CoSinkable) class (dual to [`Sinkable`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil.html#t:Sinkable), for patterns that generalize `NameBinder`)
- a general total [`NameMap`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil.html#g:4) which is useful for some implementations (e.g. conversion functions)
- unification of binders, which is useful for efficient α-equivalence implementations

- [`Control.Monad.Foil.TH`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil-TH.html) provides Template Haskell functions that generate scope-safe representation types together with some conversion functions and helpers for patterns. All of this is generated from a raw recursive representation of syntax, that has to be split into 4 types: type of variable identifiers, type of terms, type of scoped terms (to clearly understand which parts get under binders), and type of patterns.

- [`Control.Monad.Foil.Relative`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil-Relative.html) defines a variation of a relative monad typeclass specifically indexed by scope type variables of kind `S`. This is merely for the demonstration that term type constructors are monads relative to [`Name`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil-Internal.html#t:Name).

- [`Control.Monad.Free.Foil`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Free-Foil.html) defines a variation of free scoped (relative) monads relying on the foil for the scope-safe efficient handling of the binders. This module also defines

- generic substitution for this generic representation of syntax with binders
- generic α-normalization and α-equivalence checks
- generic conversion helpers

- [`Control.Monad.Free.Foil.TH`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Free-Foil-TH.html) provides Template Haskell functions that generate helpers specifically for free foil, including the generation of the signature bifunctor, convenient pattern synonyms, conversion helpers, and instances needed to enable general α-equivalence.

#### `lambda-pi` package

- [`Language.LambdaPi.Impl.Foil`](https://fizruk.github.io/free-foil/haddock/lambda-pi-0.1.0/Language-LambdaPi-Impl-Foil.html) defines a simple interpreter for λΠ-calculus with pairs, using the manually constructed scope-safe representation and conversion to and from the raw representation generated by BNFC.

- [`Language.LambdaPi.Impl.FoilTH`](https://fizruk.github.io/free-foil/haddock/lambda-pi-0.1.0/Language-LambdaPi-Impl-FoilTH.html) defines a simple interpreter for λΠ-calculus with pairs, using Template Haskell to generate a large portion of the code.

- [`Language.LambdaPi.Impl.FreeFoil`](https://fizruk.github.io/free-foil/haddock/lambda-pi-0.1.0/Language-LambdaPi-Impl-FreeFoil.html) defines a simple interpreter for λΠ-calculus with pairs, using the free foil approach.

- [`Language.LambdaPi.Impl.FreeFoilTH`](https://fizruk.github.io/free-foil/haddock/lambda-pi-0.1.0/Language-LambdaPi-Impl-FreeFoilTH.html) defines a simple interpreter for λΠ-calculus with pairs, using the free foil approach together with Template Haskell generation. This implementation has the most automation and generality.

### Scala

Scala implementation is not documented yet.

### What is not (yet) in this project

In Haskell:

1. We do not (yet) generate α-equivalence via Template Haskell or `GHC.Generics`. However, we do provide generic α-equivalence functions for `AST sig n`, and demonstrate how to implement the check manually for λΠ-terms using the foil.
2. We do not (yet) demonstrate an implementation of the typechecker for λΠ in these representations. It should be largely straightforward, since the main non-trivial part is probably the equality for the Π-types, which relies on the α-equivalence from the previous item.
3. We provide general support for patterns, but at the moment it feels somewhat ad hoc (pending proper generalization of patterns)
and also does not allow terms or scoped terms inside patterns.
Supporting terms in patterns would be desirable to enable type annotations in patterns or things like `ViewPatterns` in Haskell.
4. We do not (yet) provide strict versions of the foil and free foil here. The benchmarks, however, do implement these variations.
5. We derive [`CoSinkable`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil.html#t:CoSinkable) and [`Sinkable`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil.html#t:Sinkable) instances via Template Haskell at the moment. However, a safer and more flexible derivation should be possible via `GHC.Generics`.
6. Many functions, including [`rbind`](https://fizruk.github.io/free-foil/haddock/free-foil-0.1.0/Control-Monad-Foil-Relative.html#v:rbind) take in an extra argument of type `Scope n`, which is meant to be the runtime counterpart of the (phantom) type parameter `n :: S`. It might be possible to use [`singletons`](https://hackage.haskell.org/package/singletons) or a similar technique to avoid explicit passing of this argument, making the interface somewhat cleaner. However, since this would change the interface a lot, we do not plan on implementing this approach here.
7. Dealing with scopes generically might enable generic delayed substitution, which plays a big part in normalization by evaluation (NbE) algorithms (which outperform naïve substitution-based evaluation). It should be possible to provide a generic framework for closures of scoped terms and delayed substitutions, but we have not yet investigated that fully.
8. Free foil should allow the same generic implementation of higher-order unification as free scope monads[^2].
In fact, the parametrized metavariables should be added in the same data types à la carte fashion.
However, we do not (yet) provide any generic binder-sensitive algorithms apart from substitution and α-equivalence.
9. We do not (yet) provide a Church-encoded version of the free foil, which should improve its performance.

[^1]: Dougal Maclaurin, Alexey Radul, and Adam Paszke. 2023. _The Foil: Capture-Avoiding Substitution With No Sharp Edges._ In Proceedings of the 34th Symposium on Implementation and Application of Functional Languages (IFL '22). Association for Computing Machinery, New York, NY, USA, Article 8, 1–10.
[^2]: Nikolai Kudasov, Renata Shakirova, Egor Shalagin, Karina Tyulebaeva. 2024. _Free Foil: Generating Efficient and Scope-Safe Abstract Syntax._ 4th International Conference on Code Quality (ICCQ), Innopolis, Russian Federation, 2024, pp. 1-16 (arXiv version at )
[^3]: Nikolai Kudasov. _Free Monads, Intrinsic Scoping, and Higher-Order Preunification._ To appear in TFP 2024.