https://github.com/samsa1/modular-compiler-variants

This repository exists in order to hold OCaml variants for modular explicit and modular implicit
https://github.com/samsa1/modular-compiler-variants

Last synced: about 8 hours ago
JSON representation

This repository exists in order to hold OCaml variants for modular explicit and modular implicit

• Host: GitHub
• URL: https://github.com/samsa1/modular-compiler-variants
• Owner: samsa1
• Created: 2024-04-22T13:38:23.000Z (7 months ago)
• Default Branch: main
• Last Pushed: 2024-06-24T08:48:20.000Z (5 months ago)
• Last Synced: 2024-06-24T10:10:45.133Z (5 months ago)
• Language: OCaml
• Size: 13.7 KB
• Stars: 2
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# modular-compiler-variants

This repository exists in order to hold OCaml variants for modular explicits and modular implicit

## Install modular explicits compiler :

```

opam repo add modular-variants git+https://github.com/samsa1/modular-compiler-variants.git

opam switch create 5.2.0+modular-explicits --repos modular-variants,default

```

To have modular explicit and type arguments for modules, use the branch :

```

opam switch create 5.2.0+modexp+typearg --repos modular-variants,default

```

For testing modular implicits prototype :

```

opam switch create 5.2.0+dev+modular-implicits --repos modular-variants,default

```

## Branch 5.3.0+modular-explicits

### /!\ This version is considerer depreciated and you should consider using the branch presented below

Uses a new syntax

```ocaml

let f

    : {M : Typ} -> M.t -> M.t

    = fun {M : Typ} (x : M.t) -> x

```

## Branch 5.2.0+modular-explicits

Uses the same syntax as first-class modules and has fewer bugs

```ocaml

let f

    : (module M : Typ) -> (module Typ) -> M.t -> M.t

    = fun (module M : Typ) (module N : Typ) (x : M.t) = x

```

Modular explicits introduce a new type `(module M : S) -> t` where `M` can appear

in `t`. It is a module dependent arrow.

The types `(module M : S) -> t` and `(module S) -> t` are compatible if `M` does

not appear in `t`. Thus, modular explicits extend first-class modules by improving

their expressivity without changing how the user writes functions (this only impact types).

## Using this

A small library to help people use modular explicits (with branch `5.2.0+modular-explicits`) can be installed using :

```ocaml

opam install modexp_lib

```

An example of printing using this library is available in the example folder.

More information about this library can also be found on its repository [modexp-stdlib](https://github.com/samsa1/modexp-stdlib).