https://github.com/coalton-lang/coalton
Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.
https://github.com/coalton-lang/coalton
common-lisp functional-programming type-safety
Last synced: 2 months ago
JSON representation
Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.
- Host: GitHub
- URL: https://github.com/coalton-lang/coalton
- Owner: coalton-lang
- License: mit
- Created: 2021-08-30T19:17:09.000Z (almost 5 years ago)
- Default Branch: main
- Last Pushed: 2026-04-25T22:24:06.000Z (3 months ago)
- Last Synced: 2026-04-25T22:26:13.679Z (3 months ago)
- Topics: common-lisp, functional-programming, type-safety
- Language: Common Lisp
- Homepage: https://coalton-lang.github.io/
- Size: 14.9 MB
- Stars: 1,581
- Watchers: 32
- Forks: 96
- Open Issues: 142
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
- Citation: CITATION.cff
Awesome Lists containing this project
- awesome-lisp-languages - Coalton - L] efficient, statically typed functional programming language that supercharges Common Lisp (Languages / Common Lisp)
README
Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.
Coalton integrates directly into Common Lisp:
```lisp
(defpackage #:differentiation
(:use #:coalton #:coalton-prelude)
(:local-nicknames (#:sym #:coalton/symbol))
(:export #:Expr #:EConst #:EVar #:E+ #:E*)
(:export #:diff #:t #:d/dt))
(in-package #:differentiation)
(named-readtables:in-readtable coalton:coalton)
(coalton-toplevel
;; Define a new parametric algebraic data type for simple
;; mathematical expressions.
(define-type (Expr :t)
"A symbolic expression of basic arithmetic."
(EConst :t)
(EVar sym:Symbol)
(E+ (Expr :t) (Expr :t))
(E* (Expr :t) (Expr :t)))
;; The classic `diff` function, in Coalton.
(declare diff (Num :t => sym:Symbol * Expr :t -> Expr :t))
(define (diff x f)
"Compute the derivative of `f` with respect to `x`."
(match f
((EConst _) ; c' = 0
(EConst 0))
((EVar s) ; x' = 1
(if (== s x) (EConst 1) (EConst 0)))
((E+ a b) ; (a+b)' = a' + b'
(E+ (diff x a) (diff x b)))
((E* a b) ; (ab)' = a'b + ab'
(E+ (E* (diff x a) b)
(E* a (diff x b))))))
;; We can use `t` just fine since Coalton doesn't import `cl:t`.
(define t (sym:make-symbol "t"))
(declare d/dt (Num :t => Expr :t -> Expr :t))
(define (d/dt f)
"The time derivative operator."
(diff t f)))
```
It also works directly in the REPL:
```lisp
CL-USER> (in-package #:differentiation)
DIFFERENTIATION> (coalton-toplevel
(define (square x) (E* x x)))
;; SQUARE :: ∀ A. ((EXPR A) → (EXPR A))
DIFFERENTIATION> (coalton (d/dt (E+ (square (EVar t)) (EConst 1))))
#.(E+ #.(E+ #.(E* #.(ECONST 1) #.(EVAR |t|))
#.(E* #.(EVAR |t|) #.(ECONST 1)))
#.(ECONST 0))
```
Type errors are discovered at compile-time, and errors are printed beautifully without sacrificing Common Lisp's interactive debugging facilities.
```
DIFFERENTIATION> (coalton (d/dt (E+ (EConst 1/2) (EConst 0.5))))
error: Type mismatch
--> repl:1:32
|
1 | (coalton (d/dt (E+ (EConst 1/2) (EConst 0.5))))
| ^^^^^^^^^^^^ Expected type '(EXPR FRACTION)' but got '(EXPR F32)'
```
Coalton is currently used in production to build defense and [quantum computing software](https://coalton-lang.github.io/20220906-quantum-compiler/).
## Getting Started
> [!WARNING]
> Coalton has **not** reached "1.0" yet. This means that, from time to time, you may have a substandard user experience. While we try to be ANSI-conforming, Coalton is currently only tested on recent versions of SBCL, Allegro CL, and Clozure CL.
>
> The version of Coalton that may be in Quicklisp may not be up-to-date.
**Prepare**: Install [SBCL](http://www.sbcl.org/platform-table.html) (on macOS with Homebrew: `brew install sbcl`). Install Quicklisp by following instructions [here](https://www.quicklisp.org/beta/#installation). (The step command involving `gpg` is not needed.) After installing Quicklisp, you should have a `quicklisp` folder which will make installing Coalton easier.
**Install**: Clone this repository into a place your Lisp can see (e.g., `~/quicklisp/local-projects/`).
**Use**: Either run `(ql:quickload :coalton)`, or add `#:coalton` to your ASD's `:depends-on` list.
**Test**: Compile the tests with `(ql:quickload :coalton/tests)`, then run the tests with `(asdf:test-system :coalton)`.
> [!NOTE]
> Running the Coalton test suite on SBCL requires [GNU MPFR](https://www.mpfr.org/mpfr-current/mpfr.html#Installing-MPFR) in order to run `Big-Float` tests. If you would like to run tests without installing `gnu-mpfr`, you can use Coalton's portable `Big-Float` implementation by running `(pushnew :coalton-portable-bigfloat *features*)` before loading Coalton.
**Learn**: Start with [*Whirlwind Tour of Coalton*](docs/manual/site/topics/whirlwind-tour.md), the [language manual](https://coalton-lang.github.io/manual/), and the [standard library reference](https://coalton-lang.github.io/reference/), and then take a peek at the [examples directory](examples/). It may also be helpful to check out the [introductory blog post](https://coalton-lang.github.io/20211010-introducing-coalton/).
**Open Source Community**: [Awesome Coalton](https://github.com/Jason94/awesome-coalton) has a list of community-built libraries, applications, and examples, that you can use in your own projects or as examples to learn from.
## What's Here?
This repository contains the source code to the [Coalton compiler](src/), and the [standard library](library/).
It also contains a few example programs, such as:
- Some [simple pedagogical programs](examples/small-coalton-programs/),
- An [implementation](examples/thih/) of Jones's *Typing Haskell in Haskell*, and
- An [implementation](examples/quil-coalton/) of a simple [Quil](https://en.wikipedia.org/wiki/Quil_(instruction_set_architecture)) parser using parser combinators.
Lastly and importantly, we maintain a collection of documentation about Coalton in the [docs](docs/) directory.
## Get Involved
Want to ask a question about Coalton, propose a feature, or share a cool program you wrote? Try posting in the [GitHub Discussions](https://github.com/coalton-lang/coalton/discussions) page!
We welcome contributions of all forms, especially as we stabilize toward a 1.0 release. We would be grateful to receive:
- bug reports (filed as issues),
- bug fixes and typo corrections (filed as pull requests),
- small [example programs](examples/small-coalton-programs/), and
- user experience troubles.