28 — Monads

BJ’s recording

Friday, 17 April 2020

Programming language research seeks abstractions that help developers organize their thoughts, articulate them clearly as code, and do so effectively. They are also looking to organize their own world and understand how language constructs relate to each other, what they have in common, and how they differ. While many abstractions and organization ideas are discovered in a ‘\bottom up” manner, that is, building up from concrete examples, people in this field have always sought the kind of cross-pollination between our discipline and mathematics the way that has benefited physics for centuries.

Moggi recognized the connection between mathematical models of programming languages and the idea of Kleisli triples also known as monads. Before him Scott suggested the use of category theory in the 1970s and Cousineu, Curien, and Mauny proposed to exploit the correspondence between cartesian-closed categories and simply typed lambda calculus for the design of an abstract machine, the Categorical Abstract Machine, and with it Categorical Abstract Machine Language (CAML).—O’CAML no longer relies on these ideas. Most of these systems have adapted something called ANF or A normal form instead, a close cousin to Moggi’s monadic calculus.

This lecture is about a rather strong example of this kind. It emerged in the mid 1980s and early 1990s. The discovery coincided with several “bottom up” ideas that emerged at that time.

Sequencing vs Computing

This idea is the concern of this lecture: monads.

Lectures/28/cps-interpret.rkt

#lang racket

;; a monad interpreter that explicitly orders evaluations

(require "cps-aux.rkt")

#; {type Value =

Number ||

(function-value parameter FExpr Env) ||

[Value Kont -> Value]}

#; {type Kont = [Value -> Value]}

#; {FExpr -> Value}

;; determine the value of ae via a substitutione semantics

(define (cps-interpret ae0)

#; {FExpr Env Kont -> Value}

;; ACCUMULATOR env tracks all declarations between ae and ae0

(define (with-accu ae env k)

(match ae

[(? integer?)

(k ae)]

[(node o a1 a2)

(with-accu a2 env

(λ (right0)

(define right (number> right0))

(with-accu a1 env

(λ (left0)

(define left (number> left0))

(k (o left right))))))]

[(call ae1 ae2)

(with-accu ae2 env

(λ (right)

(with-accu ae1 env

(λ (left0)

(define left (function> left0))

(fun-apply left right k)))))]

[(fun para body)

(k (function-value para body env))]

[(if-0 tst thn els)

(with-accu tst env

(λ (t) (with-accu (if (is-zero? t) thn els) env k)))]

[(decl x a1 a2)

(with-accu a2 (decl-interpret x a1 env) k)]

[(? string?)

(if (defined? ae env)

(k (lookup ae env))

(error UNDECLARED ae))]

;; - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; let's grab continuations:

[(grab x body)

(with-accu body (add x (kont->value k) env) k)]))

#; {Value Value Kont -> Value}

(define (fun-apply function-representation argument-value k)

(match function-representation

[(? procedure?)

((function-representation argument-value) k)]

[(function-value fpara fbody env)

(with-accu fbody (add fpara argument-value env) k)]))

#; {Var (U Integer Fun) Env -> Env}

(define (decl-interpret x a1 env)

(match a1

[(? integer?) (add x a1 env)]

[(fun p b) (add-rec x (λ (env*) (function-value p b env*)) env)]))

#; {Kont -> Value}

(define (kont->value k) (λ (x) (λ (_) (k x))))

(with-accu ae0 empty (λ (x) x)))

(provide cps-interpret)

Figure 106: A Continuation-Passing Interpreter

Compare and Contrast

The following three snippets from these interpreters share a common concept, and yet, the program text cannot reveal it.

Ordering Interpreter

[(node o a1 a2)

(define right (number> (interpret a2 env)))

(define left  (number> (interpret a1 env)))

(o left right)]

Store-Passing Interpreter

[(node o a1 a2)

(define-values (right0 store+) (interpret a2 env store))

(define right (number> right0))

(define-values (left0 store++) (interpret a1 env store+))

(define left  (number> left0))

(values (o left right) store++)]

Continuation-Passing Interpreter

[(node o a1 a2)

(interpret a2 env

(λ (right0)

(define right (number> right0))

(interpret a1 env

(λ (left0)

(define left (number> left0))

(k (o left right))))))]

The idea of monads is to bring out the commonality among these three snippets.

Stop! Take a look at the store-passing version. How does it express that the store isn’t used?

Monads, Kleisli Triples, and Such

The commonality of all three code snippets is that they express an ordering among the three computations. Monads help us separate the sequencing or compositioning of computations from the computations themselves. The idea itself is to separate values from computations at the syntactic level (types, functions).

A monad module may provide additional, custom-made functions on the underlying data representation. These additional functions allow the authors of interpreters and compilers to express language features that advantage of the data structure: extend the store, update it, grab a continuations.

Commonalities Revisited

Let’s see how we express the three snippets about once we have a monad implementation for each of our concerns:

Ordering Monad Interpreter

[(node o a1 a2) (>>= (interpret a2 env)

(λ (right0)

(define right (number> right0))

(>>= (interpret a1 env)

(λ (left0)

(define left  (number> left0))

(return (o left right))))))]

Store Monad Interpreter

[(node o a1 a2)

(>>= (interpret a2 env)

(λ (right0)

(define right (number> right0))

(>>= (interpret a1 env)

(λ (left0)

(define left (number> left0))

(return (o left right))))))]

Continuation Monad Interpreter

[(node o a1 a2)

(>>= (interpret a2 env)

(λ (right0)

(define right (number> right0))

(>>= (interpret a1 env)

(λ (left0)

(define left (number> left0))

(return (o left right))))))]

No you don’t have vision problems. They really look the same. The replacement for store-passing really brings across that the store does not play a role in this part of the interpreter.

Adding Functions to Monads

A Monadic Order Interpreter

This is a finger exercise.

Lectures/28/order-monad.rkt

#lang racket

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; generic monad operation, for some type T:

(provide

#; ([Monad T] -> T)

run

#; {T -> [Monad T]}

return

#; {[Monad T] [T -> [Monad T]] -> [Monad T]}

>>=)

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; Monad[T] = T -> Symbol x T

(define GO (gensym))

(define (run m)

(define-values (result _go) (m GO))

result)

(define ((return result) _go)

(values result _go))

(define ((>>= m f) _go)

(define-values (val _go-next) (m _go))

((f val) _go-next))

Figure 107: The Plain Monad

Lectures/28/order-monad-interpret.rkt

#lang racket

;; a monad interpreter that explicitly orders evaluations

(require "./order-monad.rkt")

(require "order-aux.rkt")

#; {Value = Number || (function-value parameter FExpr Env)}

#; {FExpr -> Value}

;; determine the value of ae via a substitutione semantics

(define (order-interpret ae0)

#; {FExpr Env -> Value}

;; ACCUMULATOR env tracks all declarations between ae and ae0

(define (with-accu ae env)

(match ae

[(? integer?)

(return ae)]

[(node o a1 a2)

(>>= (with-accu a2 env)

(λ (right0)

(define right (number> right0))

(>>= (with-accu a1 env)

(λ (left0)

(define left  (number> left0))

(return (o left right))))))]

[(call ae1 ae2)

(>>= (with-accu ae2 env)

(λ (right)

(>>= (with-accu ae1 env)

(λ (left0)

(define left  (function> left0))

(fun-apply left right)))))]

[(fun para body)

(return (function-value para body env))]

[(if-0 tst thn els)

(>>= (with-accu tst env)

(λ (t) (with-accu (if (is-zero? t) thn els) env)))]

;; - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; declare variables and reference them

[(decl x a1 a2)

(with-accu a2 (decl-interpret x a1 env))]

[(? string?)

(if (defined? ae env)

(return (lookup ae env))

(error UNDECLARED ae))]))

#; {Value Value -> Value}

(define (fun-apply function-representation argument-value)

(match function-representation

[(function-value fpara fbody env)

(with-accu fbody (add fpara argument-value env))]))

(define (decl-interpret x a1 env)

(match a1

[(? integer?)

(add-rec x a1 env)]

[(fun para body)

(add-rec x (λ (r-env) (function-value para body r-env)) env)]))

(run (with-accu ae0 empty)))

(provide order-interpret)

Figure 108: Monads Emphasize Sequencing

A Monadic Continuation Interpreter

Let’s do continuations next. They are simpler than stores, an intermediate step before we get to store monads.

Lectures/28/cps-monad.rkt

#lang racket

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; generic monad operation, for some type T:

(provide

#; ([Monad T] -> T)

run

#; {T -> [Monad T]}

return

#; {[Monad T] [T -> [Monad T]] -> [Monad T]}

>>=)

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; Monad[T] = [T -> T] -> T

;; really (Value -> Answer) -> Answer && Answer ~ final Value

(define (run m)

(define result (m (λ (final-val) final-val)))

result)

(define ((return result) k)

(k result))

(define ((>>= m f) k)

(m (λ (val-m) ((f val-m) k))))

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; continuation-specific operations

(provide

#; {[Kont -> [Monad T]] -> T}

grab*)

(define [(grab* consumer-m) k]

[(consumer-m (λ (x) (λ (kp) (k x)))) k])

Figure 109: The CPS Monad

Lectures/28/cps-monad-interpret.rkt

#lang racket

;; a monad interpreter that explicitly orders evaluations

(require "./cps-monad.rkt")

(require "cps-aux.rkt")

#; {type Value =

Number ||

(function-value parameter FExpr Env) ||

[Value Kont -> Value]}

#; {type Kont = [Value -> Value]}

#; {FExpr -> Value}

;; determine the value of ae via a substitutione semantics

(define (cps-interpret ae0)

#; {FExpr Env -> Value}

;; ACCUMULATOR env tracks all declarations between ae and ae0

(define (with-accu ae env)

(match ae

[(? integer?)

(return ae)]

[(node o a1 a2)

(>>= (with-accu a2 env)

(λ (right0)

(define right (number> right0))

(>>= (with-accu a1 env)

(λ (left0)

(define left (number> left0))

(return (o left right))))))]

[(call ae1 ae2)

(>>= (with-accu ae2 env)

(λ (right)

(>>= (with-accu ae1 env)

(λ (left0)

(define left (function> left0))

(fun-apply left right)))))]

[(fun para body)

(return (function-value para body env))]

[(if-0 tst thn els)

(>>= (with-accu tst env)

(λ (t) (with-accu (if (is-zero? t) thn els) env)))]

[(decl x a1 a2)

(with-accu a2 (decl-interpret x a1 env))]

[(? string?)

(if (defined? ae env)

(return (lookup ae env))

(error UNDECLARED ae))]

;; - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; let's grab continuations:

[(grab x body)

(grab* (λ (k) (with-accu body (add x k env))))]))

#; {Value Value -> Value}

(define (fun-apply function-representation argument-value)

(match function-representation

[(? procedure?)

(function-representation argument-value)]

[(function-value fpara fbody env)

(with-accu fbody (add fpara argument-value env))]))

#; {Var (U Integer Fun) Env -> Env}

(define (decl-interpret x a1 env)

(match a1

[(? integer?) (add x a1 env)]

[(fun p b) (add-rec x (λ (env*) (function-value p b env*)) env)]))

(run (with-accu ae0 empty)))

(provide cps-interpret)

Figure 110: Monads Hide Continuations

A Monadic Store Interpreter

Here is one complex monad.

Lectures/28/store-monad.rkt

#lang racket

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; generic monad operation, for some type T:

(provide

#; ([Monad T] -> T)

run

#; {T -> [Monad T]}

return

#; {[Monad T] [T -> [Monad T]] -> [Monad T]}

>>=)

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; Monad[T] =  Store -> T x Store

(define (run m)

(define-values (result _store) (m plain))

result)

(define ((return result) store)

(values result store))

(define ((>>= m f) store)

(define-values (val store++) (m store))

((f val) store++))

;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

;; store-specific operations

(provide

#; {[Location -> [Monad T]] -> T}

alloc*

#; {Location -> [Monad T]}

retrieve*

#; {Location Value [Value ->* Value Store] -> [Monad Store]}

update*)

(require "../9/store.rkt")

(define ((alloc* f) store)

(define-values (loc store+) (alloc store #f))

((f loc) store+))

(define ((retrieve* l) store)

(values (retrieve store l) store))

(define ((update* loc val f) store)

(define old (retrieve store loc))

(define store++ (update store loc val))

((f old) store++))

Figure 111: The Store Monad