One wayto say it.

Who, for what

Built for these teams

std.typeset

Typesetting in the standard library

std.typeset in Topaz 5.21 is the standard module that breaks paragraphs into lines. The program below sets one Korean sentence at a width of ten Hangul syllables. Looking at the whole paragraph keeps a lone word off the last line.

import std.io
import std.typeset {
  BreakCluster, BreakPolicy, BreakMode, KinsokuRules, BreakOpportunity, Paragraph, Item,
  Box, Penalty, BreakRule, DistanceGrid, CostModel, LineGeometry, JustificationPolicy,
  JustificationMode, KnuthPlassPolicy, ParagraphPlan, PlanLine, classifyBreaks,
  breakParagraph,
}

let sentence = "문단 전체를 보고 줄을 나누면 마지막 줄이 짧게 남지 않고 줄마다 길이가 고르게 됩니다."
let clusters = sentence.scalars().map(cluster)
let result = classifyBreaks(clusters, koreanRules(clusters))
    .flatMap((breaks: Array<BreakOpportunity>) => breakParagraph(paragraph(clusters, breaks)))
match result {
    case Ok(plans) => {
        io.writeLine("Whole paragraph\n{linesOf(clusters, plans.optimized)}\n")
        io.writeLine("Line by line\n{linesOf(clusters, plans.greedy)}")
    }
    case Err(error) => io.writeLine("{error}")
}

Whole paragraph
문단 전체를 보고
줄을 나누면 마지막
줄이 짧게 남지
않고 줄마다 길이가
고르게 됩니다.

Line by line
문단 전체를 보고 줄을
나누면 마지막 줄이
짧게 남지 않고 줄마다
길이가 고르게
됩니다.

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, with names translated into English for illustration

View ATLAS ↗

Why Topaz handles typesetting well

One way to say it

Common tasks have one way to write them. Whether a person or an agent writes the code, it takes the same shape, so a review only has to follow what the code does.

Lispex

Topaz computes, Lispex decides

Computing such as line breaking happens in Topaz code. 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 Lispex 1.21 evaluator built into Topaz 5.21 runs those rules within the limits set in a limits file. 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 std.io
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)) => io.writeLine("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.

Built with Topaz

Beyond typesetting

The core of the Topaz compiler is written in Topaz. Browser tools are written in the same language.

function assignmentRoot(node: SyntaxNode) -> Option<SyntaxNode> {
  if node.kind == "expression/identifier" {
    return Some(node)
  }
  match child(node, "object") {
    case Some(object) => assignmentRoot(object)
    case None => None
  }
}

Explore Topaz

Choose where to go next