One wayto say it.

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 as ts

let sentence = "문단 전체를 보고 줄을 나누면 마지막 줄이 짧게 남지 않고 줄마다 길이가 고르게 됩니다."
let clusters = sentence.scalars().map(cluster)
let result = ts.classifyBreaks(clusters, koreanRules(clusters))
    .flatMap((breaks: Array<ts.BreakOpportunity>) => ts.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

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.

Business rules and data processing, too

import std.io

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
    }
}

io.writeLine("{discount({ tier: "vip", years: 7 })}")
io.writeLine("{discount({ tier: "new", years: 0 })}")

0.3
0.0

import std.io

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

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

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

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

Run independent tasks together, and close files you are done with by a cleanup step at the end of the block.

Explore Topaz

Choose where to go next

The core of the Topaz compiler is written in Topaz too.