Other languages¶

The API reference documents the Kotlin library. The Swift, Python, TypeScript, Go and Rust packages read the same catalog.tsv and answer as the Kotlin library does, checked against spec/expectations.json; this page lists what each one calls things.

Looking things up¶

A lookup that must succeed fails with:

• IllegalArgumentException in Kotlin and Java;
• a PolyglossaError (.unknownLanguage, .unknownFamily, .unknownScript) in Swift, and a catalog that cannot be read throws .notACatalog with a reason that starts with the line;
• UnknownLanguageError, UnknownFamilyError or UnknownScriptError, all KeyErrors, in Python, and a catalog that cannot be read raises a NotACatalogError, a ValueError, with the line; every one is a PolyglossaError;
• an UnknownLanguageError, UnknownFamilyError or UnknownScriptError with the code it was given in TypeScript, all PolyglossaErrors, and a catalog that cannot be read throws a NotACatalogError with the line; what is missing is null, never undefined, and what a lookup leads to is a readonly array;
• an error wrapping ErrUnknownLanguage, ErrUnknownFamily or ErrUnknownScript in Go, for errors.Is; a catalog that cannot be read gives a *ParseError with the line, for errors.As, which wraps ErrNotACatalog;
• Error::UnknownLanguage, Error::UnknownFamily or Error::UnknownScript with the code in Rust.

In Swift a language, a family or a script is a Sendable value that points into its catalog, so a catalog and all it gives can be shared between tasks; two are equal when they say the same. In Go the package's functions are on the module fenakhay.com/polyglossa/go, imported as polyglossa, and a missing text, such as a language without a Wikidata item, is "". In Rust every lookup gives a Copy handle that borrows its catalog, Language<'static> for the bundled one, and what a language, family or script leads to, such as ancestors() or languages(), comes as an iterator.

From Java¶

The Kotlin library is a Java library as well, from the same Maven coordinates. Lookups are static, a boolean reads as is…(), and what is missing is null, which the bytecode marks @Nullable for IDEs and NullAway:

import com.fenakhay.polyglossa.Catalog;
import com.fenakhay.polyglossa.Language;
import com.fenakhay.polyglossa.Script;

Language english = Language.of("en");          // throws IllegalArgumentException when there is none
Language.get("xx");                            // null
Language.named("Old English").getCode();       // "ang"
english.getFamily().getName();                 // "Anglic"
Language.of("en-US").isEtymologyOnly();        // true
Script.detect("Ελληνικά").getCode();           // "Grek"
Catalog.getBUNDLED().getDate();                // "2026-11-07"

Properties are getters, as Kotlin writes them for Java: getName(), getScripts(), getAncestors(). Lists and maps are java.util.List and java.util.Map, which Java should not change.

Language¶

LanguageType is REGULAR, RECONSTRUCTED, APPENDIX_CONSTRUCTED and ETYMOLOGY_ONLY in Kotlin and Python, .regular, .reconstructed, .appendixConstructed and .etymologyOnly in Swift, Regular, Reconstructed, AppendixConstructed and EtymologyOnly in Go and Rust, and in TypeScript Wiktionary's words themselves, a union of strings, listed in LANGUAGE_TYPES and checked with isLanguageType. Swift and Go give each one's word, regular or appendix-constructed, as its raw value, and Rust as as_str(); in Python it is a StrEnum, so each one equals its word. A Variety has name and otherNames (other_names in Python and Rust, Name and OtherNames in Go).

LanguageFamily¶

Script¶

ScriptDirection is LEFT_TO_RIGHT, RIGHT_TO_LEFT, VERTICAL_LEFT_TO_RIGHT and VERTICAL_RIGHT_TO_LEFT in Kotlin and Python, .leftToRight and so on in Swift, and LeftToRight and so on in Go and Rust, with the raw values ltr, rtl, vertical-ltr and vertical-rtl. In TypeScript it is those raw values, listed in SCRIPT_DIRECTIONS and checked with isScriptDirection.

Catalog¶

Writing a catalog and reading Wiktionary's exports are the Kotlin library's alone, as that is what records the data; the other languages read what it writes.