bin | ||
lib | ||
test | ||
dune-project | ||
README.md |
Project of "Programmation Fonctionelle Avancé"
This file is divided in two parts. The first part describes the project that you have to realise to get a partial note for the module "Programmation Fonctionelle Avancé".
PART I: Scientific content the project
To realise this project you will implement a type inference algorithm that works over terms of a programming language for functional programming.
Terms = Expressions = Programs
- Term This module contains the syntax of
the minimal programming language to we use in this project.
Terms (i.e. programs) are values of type
Term.t
. This language is "applicative", i.e. fit for functional programming, thanks to the constructors for application (App
) and for function definition (Fun
).
Aim of the project
The [third lecture] (https://gaufre.informatique.univ-paris-diderot.fr/Bernardi/pfa-2324/tree/master/week03) describes two algorithms: the first one transforms any given program into a system of equations, and the second one is a unification algorithm that solves such systems.
To realise this project you will have to implement the following modules:
-
typeSubstitution You must implement at least:
type t
, i.e. how to represent syntactic substitutions in memory,val apply
, which applies a syntactic substitution to a typeval compose
, which computes the substitution obtained composing two given substitutions.
-
unifcation You must implement at least:
val unify
which given two typet1
andt2
, must compute the substitutions
such that ifunify t1 t2 = Some s
thenapply s t1 = apply s t2
.
You can of course use the Herbrand / Robinson algorithm to start designing your implementation.
-
inference You must implement at least:
val typeof
, which given a termt
must compute eitherNone
, if there is no type fort
, orSome ty
, if ty is the type of termt
.
You may add more definitions to each of these modules, and extend their signatures accordingly.
You may also create new compilation units (i.e. new .ml
files).
- You may, and should, extend the testing module with additional tests, or replace it with a testing framework of your choice (using e.g. QCheck).
PART II: Logistics of the project
Fork
To realise your project and have it evaluated, you have to
- fork the git repository that contains this file, and
- add G. BERNARDI and G. GEOFFROY with the role
Maintainer
to your fork.
Do it asap.
Deadline
The final implementation must be in your fork by the
__ 30th of April 2024, 23h59 __
Any code pushed to your fork after that time will be ignored.
Requirements
1. Install OPAM
OPAM is the package manager for OCaml. It is the recommended way to install the OCaml compiler and OCaml packages.
The following should work for macOS and Linux:
bash -c "sh <(curl -fsSL https://raw.githubusercontent.com/ocaml/opam/master/shell/install.sh)"
Recommended: editor integration
Emacs: Tuareg & Merlin
Tuareg is an OCaml major mode for Emacs while Merlin is an editor service that provides modern IDE features for OCaml.
To install, run:
opam install tuareg merlin user-setup
VSCode: Ocaml LSP
Install the extension called OCaml Platform available in the Visual Studio Marketplace
This extension requires OCaml-LSP, an Language Server Protocol(LSP) implementation for OCaml
To install, run:
opam install ocaml-lsp-server
Development environment setup
If the required opam packages conflict with your default switch, you may setup a local Opam switch using the following commands:
$ opam switch create . --deps-only --with-doc --with-test
$ eval $(opam env)
Build
To build the project, type:
$ dune build
For continuous build, use
$ dune build --watch
instead.
Running your main file
To run your code you will have to implement
let () = ...
in the file main.ml
, and
then run it via
$ dune exec
Testing your code
To test the project, type:
$ dune runtest
This can be combined with continuous build & test, using
$ dune runtest --watch