One wayto say it.

ATLAS

A typesetting tool built with Topaz

ATLAS turns a manuscript into print-ready book pages. Here is a page it set, with part of its line-breaking rules in Topaz. ATLAS names these functions with Korean typesetting terms, shown here in English.

TOPAZCopy

function nextIsNotLatinSpace(next: Option<string>) -> bool {
  match next {
    case Some(text) => !isLatinSpace(text)
    case None => true
  }
}
function nextHasNoLineStartBan(next: Option<string>) -> bool {
  match next {
    case Some(text) => !hasLineStartBan(text)
    case None => true
  }
}

Part of the ATLAS line-breaking rules

View ATLAS ↗

Why Topaz handles typesetting well

Lispex

Topaz computes, Lispex decides

Topaz does the computing that breaks lines and builds pages. Decisions that change with each publisher and book, such as which page a chapter starts on or how many lines may stand alone, go into separate Lispex rules. The evaluator built into Topaz runs those rules within set limits. Change a rule file and lock the package again, and the same manuscript takes another style without any change to the application code.

• Rules never touch files, the system clock, or the network.
• A rule stops where it runs past its limit.
• The same rule, input, and settings give the same decision every time.

(let ((min-lines 2))
  (if (< input min-lines) "next-page" "keep"))

import src.values { singleDigit, textOf }
import std.lispex { defaultLimits, evaluate }
import std.lispex.rules as rules

export function main(args: Array<string>, stdin: string) -> Result<int, string> {
    let rule = rules.widow_lines()
    for linesLeft in [1, 2] {
        match evaluate(rule, singleDigit(linesLeft)?, defaultLimits(rule)) {
            case Ok(Complete(result)) => print("lines left {linesLeft}: {textOf(result)}")
            case _ => return Err("the rule did not finish")
        }
    }
    Ok(0)
}

lines left 1: next-page
lines left 2: keep

Lispex rules run in the interpreter and in native builds. For the full setup, including the manifest and limit files, see Run Lispex Rules.

Business rules and data processing, too

function discount(customer: { tier: string, years: int }) -> float {
    return match customer {
        case { tier: "vip", years } if years > 5 => 0.3
        case { tier: "vip" } => 0.2
        case { years } if years > 1 => 0.1
        case _ => 0.0
    }
}

print("{discount({ tier: "vip", years: 7 })}")
print("{discount({ tier: "new", years: 0 })}")

0.3
0.0

function clean(words: Array<string>) -> Array<string> {
    return filter(words, (w: string) => w != "")
}

function shout(words: Array<string>) -> Array<string> {
    return map(words, (w: string) => w + "!")
}

let line = ["one", "", "way", "", "to", "say", "it"]
    |> clean
    |> shout
print("{line}")

[one!, way!, to!, say!, it!]

Concurrency and cleanup examples are in Concurrency and Defer & Resources.

Explore Topaz

Understand Topaz, then learn, look something up, or build.

Start with what Topaz is for. Then follow the guided path, scan the syntax map when you need a quick answer, or choose a toolchain destination. The compiler you install is itself written in Topaz. How the compiler checks its own build →