Skip to content
(MIRROR) An efficient dependently-typed systems programming language and proof assistant.
Branch: master
Clone or download
MaisaMilena Merge branch 'maisa/14-update-compilation-img' into 'master'
[Issue-14] Fix details on doc images

See merge request moonad/formality!12
Latest commit 024e19e Jul 15, 2019
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
docs [Issue-14] Fix details on doc images Jul 15, 2019
spec Corrections on the typing rules. Jul 9, 2019
stdlib [Issue-9] Update Formality-Core's stdlib style Jul 10, 2019
.gitignore Pattern matching compilation Nov 21, 2018
LICENSE Add LICENSE Jun 30, 2019
README.md Update links Jun 29, 2019

README.md

Formality

A upcoming efficient proof-gramming language. It aims to be:

  • Fast: no garbage-collection, optimal beta-reduction and a massively parallel GPU compiler make it fast.

  • Safe: a type system capable of proving mathematical theorems about its own programs make it secure.

  • Portable: the full language is implemented in a 400-LOC runtime, making it easily available everywhere.

Formality isn't ready yet, but you can already use Formality-Core, our low-level compile target (check its wiki!), and EA-TT, our underlying proof language.

Projects

For a better separation of concerns, Formality was broken down into sub-projects:

Features Calculus Type-Theory Runtime
Lam, Box EA-Core EA-TT EA-Net
Lam, Box, Pair, Uint32 FM-Core FM-TT FM-Net

FM-Core is our low-level, untyped compile target, FM-TT is our raw type theory and FM-Net is our efficient interaction-net runtime. EA-Core, EA-TT and EA-Net are their formalization-friendly counterparts, excluding native ints to be easier to reason about. Formality will be a high-level, Python/Agda-inspired syntax built on top of those. Here is a sneak peek!

Progress Table

Note: most reference implementations were written in JavaScript simply because it is a cross-platform language, but we plan to re-implement all those things inside Formality-Core. Once this is done, we will port them Haskell, Rust, Python etc. by a simple bootstrapping process: 1. implement just the runtime (FM-Net, a 400-LOC file), 2. load the desired lib on it.

Project Description Implementation(s)
EA-Core Parser, interpreter. JavaScript
EA-Core EA-Net compiler/decompiler. JavaScript
EA-Core Command-line interface. JavaScript
EA-Core Formalization. Agda (ongoing)
EA-Core Specification. Markdown (ongoing)
EA-Net Strict and Lazy runtime. EA-Core
EA-TT Parser, interpreter, type-checker. JavaScript
EA-TT EA-Core compiler/decompiler. JavaScript
EA-TT Command-line interface. JavaScript
EA-TT Specification. Markdown (ongoing)
FM-Core Parser, interpreter. JavaScript, FM-Core (ongoing)
FM-Core FM-Net compiler/decompiler. JavaScript
FM-Core JS compiler/decompiler. JavaScript
FM-Core Command-line interface. JavaScript
FM-Core Documentation. Markdown (ongoing)
FM-Net Strict and Lazy runtime. JavaScript, C (ongoing), OpenCL (redo), CUDA (redo)
FM-Net Documentation. Markdown (ongoing)
FM-TT Parser, interpreter, type-checker. FM-Core (todo)
FM-TT FM-Core compiler/decompiler. FM-Core (todo)
FM-TT Specification. Markdown (todo)
FM-Lang Parser, interpreter, type-checker. FM-Core (todo)
FM-Lang Documentation Markdown (todo)
LIB Mutable Arrays. FM-Core
LIB Linked lists. FM-Core
LIB UTF-8 strings. FM-Core
LIB Demo: numeric algorithms. FM-Core
LIB Demo: theorems and proofs. Elementary Affine Type Theory
You can’t perform that action at this time.