Type Classes

Type classes provide ad-hoc polymorphism in Monad, similar to Haskell type classes and Rust traits. They allow you to define interfaces that types can implement.

Basic Syntax

Define a type class with the class keyword:

class Container (F : Type -> Type) {
    def wrap : A -> F A
    def size (fa : F A) : I64
}

Default Implementations

Class methods may provide a default body with :=:

class Describe A {
    def describe (a : A) : String := "<generic>"
    def shout (a : A) : String
}

Two limitations to be aware of today:

An instance must still list every method it wants, including ones it is happy to take the default of. An empty instance body { } is a parse error, so there is no way to write "use all the defaults". The prelude's MonadState is the first shipped class with real defaults, and examples/state_monad.mo duly spells out all five of its methods, modify and get_map included.
Instance methods need full type annotations. def describe x := "int" does not parse; write def describe (x : I64) : String := "int".

class Describe A {
    def describe (a : A) : String := "<generic>"
}

instance Describe I64 {
    def describe (x : I64) : String := "int"
}

Classes with Constraints

Type classes can require other classes as constraints:

class [Functor F] Applicative (F : Type -> Type) {
    def pure : A -> F A
    def apply : F (A -> B) -> F A -> F B
}

class [Applicative M] Monad (M : Type -> Type) {
    def bind (a : M A) (f : A -> M B) : M B
    def pure : A -> M A
}

The [Functor F] syntax means "F must have a Functor instance".

Multiple Parameters

Classes can have multiple type parameters:

class Convert A B {
    def convert : A -> B
}

Default Type Parameters

A class parameter can have a default, which is used when the class is named without one:

class FromListLiteral (L : Type -> Type := List) {
    def cons (a : A) (L A) : L A
    def empty : L A
}

Type Class Constraints on Functions

Functions can require instances using bracket syntax:

def process [Functor F] {A B : Type} (f : A -> B) (fa : F A) : F B :=
    Functor.map f fa

Infix Operators from Classes

You can bind an infix operator to any function, including a class method:

infix (>>=) := Monad.bind
infix (+) := HAdd.add
infix (*) := HMul.mul

The Standard Classes

These are the classes that actually ship. Note where each one lives — only the prelude ones are available without an import.

In the prelude (no import needed)

Class	Methods	Notes
`Functor (F : Type -> Type)`	`map`
`Applicative (F)`	`pure`, `apply`	requires `Functor`
`Monad (M)`	`bind`, `pure`	requires `Applicative`
`IndexedMonad (M)`	`pure`, `bind`, `map`, `and_then`, `lift`	indexed by two phantom parameters
`MonadState (M)`	`get`, `set`, `modify_get`, `modify`, `get_map`	* has a default body. The state type is an implicit forall, not a class parameter
`MonadLift m n`	`monad_lift`	lift a computation from `m` into `n`
`MonadLiftT m n`	`monad_lift_t`	transitive form; the reflexive `MonadLiftT m m` instance does not dispatch (see below)
`IndexedMonadState (M)`	`get`, `set`, `modify_get`	indexed counterpart of `MonadState`
`IndexedMonadLift m n`	`monad_lift`	indexed counterpart of `MonadLift`
`FromListLiteral (L := List)`	`cons`, `empty`	drives `[a, b, c]`
`HAdd A B C` / `Add A`	`add`	`+` binds `HAdd.add`
`HMul A B C`	`mul`	`*`
`Sub A`	`sub`	`-`
`Div A`	`div`	`/`
`Append A`	`append`	`++`
`BEq A`	`beq`	`==`
`BOrd A`	`lt`, `gt`	`<`, `>`
`ToString A`	`to_string`
`Hashable A`	`hash`

Add and HAdd are wired to each other in both directions: an HAdd A A A instance gives you Add A, and vice versa.

Elsewhere in the standard library

Class	Module	Methods
`From T A`	`init`	`from`
`Semigroup A`	`init.foldable`	`combine`
`Monoid A`	`init.foldable`	`mempty`
`Foldable (T)`	`init.foldable`	`foldr`, `foldl`
`Traversable (T)`	`init.foldable`	`traverse`
`Ord A`	`std.base`	`compare` (three-way, returns `Ordering`)
`Semigroup A`	`std.base`	`combine`
`Monoid A`	`std.base`	`empty`
`Default A`	`std.base`	`default`
`Enum A`	`std.base`	`succ`, `pred`, `to_nat`, `from_nat`
`Bounded A`	`std.base`	`min_bound`, `max_bound`
`Show A`	`std.show`	`show`
`Debug A`	`std.debug`	`debug`
`Map (M := HashMap)`	`std.map`	`empty`, `insert`, `lookup`, `delete`

Known wart. Semigroup and Monoid are declared twice — once in init/foldable.mo and once in std/base.mo — with different method names (mempty vs empty). They are unrelated classes that happen to share a name. Import only one of them in a given file.

Show and Debug are deliberately different: Debug is a Rust-style diagnostic representation (it quotes strings), Show is a display string. ToString, in the prelude, is what the numeric types implement.

There is no Mul class (only HMul), and DefaultValue in the prelude is a type, not a class — the class you want is Default in std.base.

Instance Resolution Is Not Fully Checked

Instance resolution happens during evaluation, not during check. A program that uses a class method with no matching instance will type-check cleanly and then fail at run time:

eval error: unresolved global: Monad.bind

This is a real gap, not a subtlety of the design — see the Maturity Matrix. If you are relying on an instance, run the code (or a #[test]), do not just check it.

There is a second, quieter version of the same problem. Resolution keys on the head of the instance's type, so an instance whose head is a type variable can never be matched. The prelude ships two — instance MonadLiftT m m and the instance {I : Type} [IndexedMonad M] Monad (M I I) bridge — and both are, in practice, declarations of intent. Write the concrete instance out instead; see Instances.

Summary

Type classes define interfaces for types
Constraints [C A] require instances, on both classes and functions
Instance methods need full annotations, and instance bodies cannot be empty
A missing instance is currently a run-time error, not a check-time one

Next, we'll learn about instances and how to implement type classes.

Monad language