coalton-lang/coalton

---

coalton-lang/coalton.json

{
  "createdAt": "2021-08-30T19:17:09Z",
  "defaultBranch": "main",
  "description": "Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.",
  "fullName": "coalton-lang/coalton",
  "homepage": "https://coalton-lang.github.io/",
  "language": "Common Lisp",
  "name": "coalton",
  "pushedAt": "2025-11-25T16:43:19Z",
  "stargazersCount": 1483,
  "topics": [
    "common-lisp",
    "functional-programming",
    "type-safety"
  ],
  "updatedAt": "2025-11-25T16:43:23Z",
  "url": "https://github.com/coalton-lang/coalton"
}

Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

Coalton integrates directly into Common Lisp:

(defpackage #:differentiation
  (:use #:coalton #:coalton-prelude)
  (:local-nicknames (#:sym #:coalton-library/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
    "The time derivative operator."
    (diff t)))

It also works directly in the REPL:

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.

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.

Coalton will not be in Quicklisp until it reaches its first stable version.

Prepare: Install SBCL (on macOS with Homebrew: brew install sbcl). Install Quicklisp by following instructions here. (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 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 [Intro to Coalton]!(docs/intro-to-coalton.md) and the standard library reference, and then take a peek at the [examples directory]!(examples/). It may also be helpful to check out the introductory blog post.

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 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 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.