The document describes the implementation of a math typesetting module in the Satyrographos programming language. It defines types like math and math-element to represent mathematical expressions. Functions like output and output-element are used to convert a math expression to a string by mapping over its elements. Special characters are wrapped in calls to make-char-info to handle properties like color. Let-math is used to define relational operators like ≤ by combining character, class, and color information.

4. @zr_tex8r
otfm

8. refactor-internal

12. F-ing modules [Rossberg, Russo & Dreyer 2014]
direct
open

13. signature Ord = sig
type t
val compare : t -> t -> int
end
module MakeMap(Key : Ord) : (sig
type key
type ’v t
val empty : ’v t
val add : key -> ’v -> ’v t -> ’v t
⋮
end with key = Key.t) = struct
⋮
end

14. signature Ord = sig
type t
val compare : t -> t -> int
end
module MakeMap(Key : Ord) : (sig
type key
type ’v t
val empty : ’v t
val add : key -> ’v -> ’v t -> ’v t
⋮
end with key = Key.t) = struct
⋮
end

15. signature Ord = sig
type t
val compare : t -> t -> int
end
module MakeMap(Key : Ord) : (sig
type key
type ’v t
val empty : ’v t
val add : key -> ’v -> ’v t -> ’v t
⋮
end with key = Key.t) = struct
⋮
end
NumberMap
module NumberMap =
MakeMap(struct
type t = int
let compare x y = y - x
end)

16. code
@require code
module PythonCode =
Code.Make(struct
val base-font = (`Menlo`, 1., 0.)
val highlight = Code.Syntax.python
end)
⋮
{… PythonCode.code(`print(“Hi!")`); …}

17. code
@require code
open
Code.Make(struct
val base-font = (`Menlo`, 1., 0.)
val highlight = Code.Syntax.python
end)
⋮
{… code(`print(“Hi!")`); …}
open

19. context
module FontScheme : sig
val set-italic : string -> context -> context
val get-italic : context -> string
⋮
end = struct
context-entry ##italic : string = `Junicode-it`
let set-italic name ctx = (ctx with ##italic = name)
let get-italic ctx = ctx##italic
⋮
end

20. context-entry ##italic : string = `Junicode-it`
ctx##italic
(ctx with ##italic = name)

22. %list.satyg
module List : sig
⋮
val map : ('a -> 'b) -> 'a list -> 'b list
@doc {
`List.map f xs` `xs`
`f`
}
⋮
end = struct
⋮
end
$ satysfi doc generate list.satyg

23. % bnf.satyh
@require math
@doc @require code
@doc @require math
@doc open Math
@doc @require bnf
module Bnf : sig
val bnf : [math; (math list) list] inline-cmd
@doc {
BNF 1
2
Code.display(```
Bnf.bnf(${M})[
${| c | x | M M | lambda x. M |};
${| text!{let} x = M text!{in} M |};
];
```);%
Bnf.bnf(${M})[
${| c | x | M M | lambda x. M |};
${| text!{let} x = M text!{in} M |};
];%
}
end = struct … end

25. math-char math-paren inline-result
inline-result inline-boxes string
type math-class = MathOrd | MathBin | …
type math = math-element list
and math-element =
| MathSuperscript of math * math
| MathSubscript of math * math
| MathFraction of math * math
| MathChar of math-class * math-char
| MathParen of math-paren * math-paren * math
| MathGeneralInline of inline-result
⋮

26. let-rec output (m : math) : string =
String.concat ` ` (List.map output-element m)
and output-element elem =
match elem with
| MathSuperscript(m1, m2) ->
output m1 ^ `_{` ^ output m2 ^ `}`
| MathSubscript(m1, m2) ->
output m1 ^ `^{` ^ output m2 ^ `}`
| MathFraction(m1, m2) ->
`frac{` ^ output m1 ^ `}{` ^ output m2 ^ `}`
| MathChar(mclass, mchar) ->
… %
⋮

27. let-math
let-math tinfo leq =
let color = get-text-color tinfo in
let char = make-char-info `≤` (| color = color; … |) in
MathChar(MathRel, char)
mathord{textcolor{0,0,0}{3.05}}
mathrel{textcolor{0,0,0}{leq}}
mathord{textcolor{0,0,0}{pi}}
${3.05 leq pi}