🥮 mooncakes.io

moonlocale

Application-focused internationalization and localization toolkit for MoonBit

i18n
l10n
locale
message-format
plural
moon add zlhahaha/moonlocale@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
19 days ago
Downloads
3
README

#MoonLocale

MoonLocale is a dependency-free internationalization and localization toolkit for MoonBit applications. It covers the routines that product code needs every day: locale negotiation, translated message catalogs, plurals, numbers, currencies, dates, lists, relative time, units, byte sizes, durations, and pseudo-localization.

The package is deterministic and does not depend on an operating-system locale database, so the same input produces the same text on native and WebAssembly targets.

#Install

moon add zlhahaha/moonlocale

Then import the package in moon.pkg:

import {
  "zlhahaha/moonlocale",
}

#Quick start

fn main {
  let en = @moonlocale.Locale::parse("en").unwrap()
  let catalog = @moonlocale.MessageCatalog::compile(en, [
    @moonlocale.message_resource(
      "inbox",
      "{count, plural, one {Hello {name}, one message} other {Hello {name}, # messages}}",
    ),
  ]).unwrap()
  let bundle = @moonlocale.MessageBundle::new(en, [catalog]).unwrap()
  let text = bundle.format(
    @moonlocale.Locale::parse("en-GB").unwrap(),
    "inbox",
    [
      @moonlocale.string_argument("name", "Mina"),
      @moonlocale.int_argument("count", 2500),
    ],
  ).unwrap()
  println(text) // Hello Mina, 2,500 messages
}

See examples/basic for a runnable example:

moon run examples/basic

#What it provides

  • Practical BCP 47 locale parsing, normalization, fallback chains, and matching.
  • Cardinal and ordinal plural rules for commonly used language families.
  • ICU-inspired messages with variables, select, plural, selectordinal, exact selectors, offsets, nesting, and apostrophe escaping.
  • Compiled catalogs, per-message locale fallback, and contextual errors.
  • Integer, decimal, percentage, and currency formatting without floating-point rounding surprises.
  • Validated civil dates and times with localized date and time styles.
  • Conjunction, disjunction, relative-time, measurement-unit, byte-size, and duration formatting.
  • Pseudo-localization and catalog audits for missing, extra, or incompatible translations.

#Locale behavior

Locale::parse accepts common tags such as en-US, zh_Hans_CN, and sl-Latn-SI-rozaj, then emits a normalized tag. best_locale first attempts an exact match and progressively falls back through script, region, and language. Message bundles also fall back per key, so a regional catalog can contain only the strings it overrides.

MoonLocale intentionally ships a compact, application-oriented ruleset rather than the full Unicode CLDR dataset. Unknown locales use stable English-like defaults. This keeps binaries and behavior predictable while leaving room for additional locale data in future releases.

#Message syntax

Welcome, {name}
{role, select, admin {Administrator} other {Member}}
{count, plural, =0 {Empty} one {# item} other {# items}}
{rank, selectordinal, one {#st} two {#nd} few {#rd} other {#th}}
{count, plural, offset:1 =0 {Nobody came} one {{name} came} other {{name} and # others came}}

Templates are parsed when a catalog is compiled. Invalid syntax, duplicate keys, missing arguments, and incompatible argument types are returned as typed errors instead of being silently ignored.

#Quality checks

let audit = @moonlocale.audit_catalogs(reference, translations)
if !audit.is_complete() {
  for issue in audit.issues() {
    println(issue.message())
  }
}

let preview = reference.pseudo_localized(
  @moonlocale.Locale::parse("en-XA").unwrap(),
)

Pseudo-localization preserves placeholders and message branches while accenting and expanding visible text, which makes clipped UI and untranslated strings easier to find.

#Development

moon fmt
moon check --deny-warn
moon build
moon test --deny-warn
moon run examples/basic

#License

Apache-2.0. See LICENSE.

#
BundleBuildError

source
pub(all) enum BundleBuildError {
  EmptyBundle
  DuplicateCatalog(String)
  MissingDefaultCatalog(String)
} derive(Eq, 
Debug)

Errors found while combining locale catalogs into one bundle.

#
BundleBuildError::message

source
fn BundleBuildError::message(self : BundleBuildError) -> String

#
BundleFormatError

source
pub(all) enum BundleFormatError {
  MissingMessage(String, Array[String])
  MessageFormattingFailed(String, String, MessageFormatError)
} derive(Eq, 
Debug)

Failures produced while resolving and formatting a bundled message.

#
BundleFormatError::message

source
fn BundleFormatError::message(self : BundleFormatError) -> String

#
ByteSizeStyle

source
pub(all) enum ByteSizeStyle {
  DecimalBytes
  BinaryBytes
} derive(Eq, 
Debug)

Controls the base used when automatically scaling byte quantities.

#
CatalogAudit

source
pub struct CatalogAudit {
  reference_locale : Locale
  checked_catalogs : Int
  issues : Array[CatalogAuditIssue]
} derive(Eq, 
Debug)

Summary of a reference-to-translations catalog comparison.

#
CatalogAudit::argument_mismatch_count

source
fn CatalogAudit::argument_mismatch_count(self : CatalogAudit) -> Int

#
CatalogAudit::checked_catalogs

source
fn CatalogAudit::checked_catalogs(self : CatalogAudit) -> Int

#
CatalogAudit::is_complete

source
fn CatalogAudit::is_complete(self : CatalogAudit) -> Bool

#
CatalogAudit::issues

source

#
CatalogAudit::missing_count

source
fn CatalogAudit::missing_count(self : CatalogAudit) -> Int

#
CatalogAudit::reference_locale

source
fn CatalogAudit::reference_locale(self : CatalogAudit) -> Locale

#
CatalogAudit::unexpected_count

source
fn CatalogAudit::unexpected_count(self : CatalogAudit) -> Int

#
CatalogAuditIssue

source
pub(all) enum CatalogAuditIssue {
  MissingKey(String, String)
  UnexpectedKey(String, String)
  ArgumentSetMismatch(String, String, Array[String], Array[String])
} derive(Eq, 
Debug)

A concrete difference between a reference catalog and a translation.

#
CatalogAuditIssue::key

source
fn CatalogAuditIssue::key(self : CatalogAuditIssue) -> String

#
CatalogAuditIssue::locale_tag

source
fn CatalogAuditIssue::locale_tag(self : CatalogAuditIssue) -> String

#
CatalogAuditIssue::message

source
fn CatalogAuditIssue::message(self : CatalogAuditIssue) -> String

#
CatalogCompileError

source
pub(all) enum CatalogCompileError {
  EmptyMessageKey(Int)
  DuplicateMessageKey(String)
  InvalidMessage(String, MessageParseError)
} derive(Eq, 
Debug)

Errors found while compiling one locale's message resources.

#
CatalogCompileError::message

source
fn CatalogCompileError::message(self : CatalogCompileError) -> String

#
CatalogMessage

source
pub struct CatalogMessage {
  key : String
  template : MessageTemplate
} derive(Eq, 
Debug)

A parsed message associated with its stable application key.

#
CatalogMessage::key

source
fn CatalogMessage::key(self : CatalogMessage) -> String

#
CatalogMessage::template

source

#
CivilDate

source
pub struct CivilDate {
  year : Int
  month : Int
  day : Int
} derive(Compare, Eq, 
Debug)

A Gregorian calendar date without a time zone.

#
CivilDate::day

source
fn CivilDate::day(self : CivilDate) -> Int

#
CivilDate::month

source
fn CivilDate::month(self : CivilDate) -> Int

#
CivilDate::new

source
fn CivilDate::new(year : Int, month : Int, day : Int) -> Result[CivilDate, DateTimeError]

#
CivilDate::to_iso_string

source
fn CivilDate::to_iso_string(self : CivilDate) -> String

#
CivilDate::weekday

source
fn CivilDate::weekday(self : CivilDate) -> Weekday

#
CivilDate::year

source
fn CivilDate::year(self : CivilDate) -> Int

#
CivilTime

source
pub struct CivilTime {
  hour : Int
  minute : Int
  second : Int
} derive(Compare, Eq, 
Debug)

A wall-clock time without a date or time zone.

#
CivilTime::hour

source
fn CivilTime::hour(self : CivilTime) -> Int

#
CivilTime::minute

source
fn CivilTime::minute(self : CivilTime) -> Int

#
CivilTime::new

source
fn CivilTime::new(hour : Int, minute : Int, second : Int) -> Result[CivilTime, DateTimeError]

#
CivilTime::second

source
fn CivilTime::second(self : CivilTime) -> Int

#
CivilTime::to_iso_string

source
fn CivilTime::to_iso_string(self : CivilTime) -> String

#
CurrencyDisplay

source
pub(all) enum CurrencyDisplay {
  Symbol
  NarrowSymbol
  Code
  Name
} derive(Eq, 
Debug)

Controls how a currency identifier is displayed.

#
DateStyle

source
pub(all) enum DateStyle {
  Numeric
  Short
  Medium
  Long
  Full
} derive(Eq, 
Debug)

#
DateTimeError

source
pub(all) enum DateTimeError {
  InvalidYear(Int)
  InvalidMonth(Int)
  InvalidDay(Int)
  InvalidHour(Int)
  InvalidMinute(Int)
  InvalidSecond(Int)
} derive(Eq, 
Debug)

Reports invalid civil date and clock values.

#
DateTimeError::message

source
fn DateTimeError::message(self : DateTimeError) -> String

#
DateTimeFormatter

source
pub struct DateTimeFormatter {
  locale : Locale
  date_style : DateStyle
  hour_cycle : HourCycle
  include_seconds : Bool
} derive(Eq, 
Debug)

#
DateTimeFormatter::format_date

source
fn DateTimeFormatter::format_date(self : DateTimeFormatter, date : CivilDate) -> String

#
DateTimeFormatter::format_datetime

source
fn DateTimeFormatter::format_datetime(self : DateTimeFormatter, date : CivilDate, time : CivilTime) -> String

#
DateTimeFormatter::format_time

source
fn DateTimeFormatter::format_time(self : DateTimeFormatter, time : CivilTime) -> String

#
DateTimeFormatter::new

source

#
DateTimeFormatter::with_date_style

source
fn DateTimeFormatter::with_date_style(self : DateTimeFormatter, style : DateStyle) -> DateTimeFormatter

#
DateTimeFormatter::with_hour_cycle

source
fn DateTimeFormatter::with_hour_cycle(self : DateTimeFormatter, cycle : HourCycle) -> DateTimeFormatter

#
DateTimeFormatter::with_seconds

source
fn DateTimeFormatter::with_seconds(self : DateTimeFormatter, enabled : Bool) -> DateTimeFormatter

#
Decimal

source
pub struct Decimal {
  coefficient : Int
  scale : Int
} derive(Eq, 
Debug)

A base-10 value represented without binary floating-point rounding.

Decimal::new(12345, 2) represents 123.45. Trailing fractional zeroes are normalized so equality is based on the numeric value.

#
Decimal::coefficient

source
fn Decimal::coefficient(self : Decimal) -> Int

#
Decimal::from_int

source
fn Decimal::from_int(value : Int) -> Decimal

#
Decimal::is_zero

source
fn Decimal::is_zero(self : Decimal) -> Bool

#
Decimal::new

source
fn Decimal::new(coefficient : Int, scale : Int) -> Decimal

#
Decimal::round

source
fn Decimal::round(self : Decimal, fraction_digits : Int) -> Decimal

Rounds to a fixed number of fractional digits, with halfway values rounded away from zero.

#
Decimal::scale

source
fn Decimal::scale(self : Decimal) -> Int

#
Decimal::times_int

source
fn Decimal::times_int(self : Decimal, factor : Int) -> Decimal

Multiplies a decimal by an integer factor.

#
DecimalFormatter

source
pub struct DecimalFormatter {
  locale : Locale
  grouping : Bool
  minimum_fraction_digits : Int
  maximum_fraction_digits : Int
  sign_display : SignDisplay
} derive(Eq, 
Debug)

Locale-aware options for decimal, percentage, and currency output.

#
DecimalFormatter::format

source
fn DecimalFormatter::format(self : DecimalFormatter, value : Decimal) -> String

Formats a decimal with deterministic base-10 rounding.

#
DecimalFormatter::format_percent

source
fn DecimalFormatter::format_percent(self : DecimalFormatter, value : Decimal, spacing : PercentSpacing) -> String

Formats a ratio as a percentage. Decimal::new(125, 3) becomes 12.5%.

#
DecimalFormatter::locale

source

#
DecimalFormatter::new

source

#
DecimalFormatter::with_grouping

source
fn DecimalFormatter::with_grouping(self : DecimalFormatter, enabled : Bool) -> DecimalFormatter

#
DecimalFormatter::with_maximum_fraction_digits

source
fn DecimalFormatter::with_maximum_fraction_digits(self : DecimalFormatter, digits : Int) -> DecimalFormatter

Sets the maximum fraction digits, clamped to 0 through 12.

#
DecimalFormatter::with_minimum_fraction_digits

source
fn DecimalFormatter::with_minimum_fraction_digits(self : DecimalFormatter, digits : Int) -> DecimalFormatter

Sets the minimum fraction digits, clamped to 0 through 12.

#
DecimalFormatter::with_sign_display

source
fn DecimalFormatter::with_sign_display(self : DecimalFormatter, display : SignDisplay) -> DecimalFormatter

#
HourCycle

source
pub(all) enum HourCycle {
  LocaleDefault
  Hour12
  Hour24
} derive(Eq, 
Debug)

#
ListFormatter

source
pub struct ListFormatter {
  locale : Locale
  list_type : ListType
  width : ListWidth
} derive(Eq, 
Debug)

#
ListFormatter::format

source
fn ListFormatter::format(self : ListFormatter, values : Array[String]) -> String

Joins already-rendered values using locale punctuation and conjunctions.

#
ListFormatter::new

source
fn ListFormatter::new(locale : Locale) -> ListFormatter

#
ListFormatter::with_type

source
fn ListFormatter::with_type(self : ListFormatter, list_type : ListType) -> ListFormatter

#
ListFormatter::with_width

source
fn ListFormatter::with_width(self : ListFormatter, width : ListWidth) -> ListFormatter

#
ListType

source
pub(all) enum ListType {
  And
  Or
  Unit
} derive(Eq, 
Debug)

#
ListWidth

source
pub(all) enum ListWidth {
  Long
  Short
  Narrow
} derive(Eq, 
Debug)

#
Locale

source
pub struct Locale {
  language : String
  script : String?
  region : String?
  variants : Array[String]
} derive(Eq, 
Debug)

A normalized, practical subset of a BCP 47 language tag.

MoonLocale keeps the language, optional script, optional region, and any remaining variants separately. This is sufficient for application locale negotiation without coupling callers to a large standards database.

#
Locale::fallback_chain

source
fn Locale::fallback_chain(self : Locale) -> Array[Locale]

Produces a most-specific-to-least-specific fallback chain.

For zh-Hans-CN-posix, this returns zh-Hans-CN-posix, zh-Hans-CN, zh-Hans, and zh.

#
Locale::from_string

source
fn Locale::from_string(tag : String) -> Locale?

Creates a locale and returns None for an invalid tag.

#
Locale::language

source
fn Locale::language(self : Locale) -> String

#
Locale::language_only

source
fn Locale::language_only(self : Locale) -> Locale

Returns only the language component.

#
Locale::match_score

source
fn Locale::match_score(self : Locale, candidate : Locale) -> Int

Measures how closely two locales match.

A negative score means the languages differ. Higher scores prefer exact tags, then matching scripts, regions, and variants.

#
Locale::parse

source
fn Locale::parse(tag : String) -> Result[Locale, LocaleError]

Parses a locale tag such as en, pt-BR, or zh-Hans-CN.

Underscores are accepted as a convenience for operating-system locale values. The returned locale always renders with hyphens and conventional casing.

#
Locale::region

source
fn Locale::region(self : Locale) -> String?

#
Locale::script

source
fn Locale::script(self : Locale) -> String?

#
Locale::tag

source
fn Locale::tag(self : Locale) -> String

#
Locale::variants

source
fn Locale::variants(self : Locale) -> Array[String]

#
Locale::without_region

source
fn Locale::without_region(self : Locale) -> Locale

Returns the locale with its region removed.

#
Locale::without_variants

source
fn Locale::without_variants(self : Locale) -> Locale

Returns the locale with all variants removed.

#
LocaleError

source
pub enum LocaleError {
  EmptyTag
  EmptySubtag(Int)
  InvalidLanguage(String)
  InvalidVariant(String)
  DuplicateScript(String)
  DuplicateRegion(String)
} derive(Eq, 
Debug)

Reports why a locale tag could not be parsed.

#
LocaleError::message

source
fn LocaleError::message(self : LocaleError) -> String

#
MeasurementUnit

source
pub(all) enum MeasurementUnit {
  Meter
  Kilometer
  Centimeter
  Millimeter
  SquareMeter
  Hectare
  Liter
  Milliliter
  Gram
  Kilogram
  MeterPerSecond
  KilometerPerHour
  BitPerSecond
  KilobitPerSecond
  MegabitPerSecond
  Celsius
  Fahrenheit
  Byte
  Kilobyte
  Megabyte
  Gigabyte
  Terabyte
  Kibibyte
  Mebibyte
  Gibibyte
  Tebibyte
  Millisecond
  Second
  Minute
  Hour
  Day
} derive(Eq, 
Debug)

Units commonly displayed by consumer, business, and system applications.

#
MessageArgument

source
pub struct MessageArgument {
  name : String
  value : MessageValue
} derive(Eq, 
Debug)

A named value passed to MessageTemplate::format.

#
MessageArgument::name

source
fn MessageArgument::name(self : MessageArgument) -> String

#
MessageArgument::new

source
fn MessageArgument::new(name : String, value : MessageValue) -> MessageArgument

#
MessageArgument::value

source

#
MessageBundle

source
pub struct MessageBundle {
  default_locale : Locale
  catalogs : Array[MessageCatalog]
} derive(Eq, 
Debug)

A set of locale catalogs with deterministic per-message fallback.

Resolution tries the request's exact fallback chain first, then the closest catalog in the same language, and finally the default locale. If a catalog exists but lacks the requested key, resolution continues to the next candidate. This allows regional catalogs to override only selected strings.

#
MessageBundle::catalog_count

source
fn MessageBundle::catalog_count(self : MessageBundle) -> Int

#
MessageBundle::default_locale

source
fn MessageBundle::default_locale(self : MessageBundle) -> Locale

#
MessageBundle::format

source
fn MessageBundle::format(self : MessageBundle, requested : Locale, key : String, arguments : Array[MessageArgument]) -> Result[String, BundleFormatError]

Resolves and formats one localized message.

#
MessageBundle::new

source
fn MessageBundle::new(default_locale : Locale, catalogs : Array[MessageCatalog]) -> Result[MessageBundle, BundleBuildError]

#
MessageBundle::resolve

source
fn MessageBundle::resolve(self : MessageBundle, requested : Locale, key : String) -> Result[ResolvedMessage, BundleFormatError]

Resolves a key and reports which locale supplied the message.

#
MessageBundle::supported_locales

source
fn MessageBundle::supported_locales(self : MessageBundle) -> Array[Locale]

#
MessageCase

source
pub struct MessageCase {
  selector : String
  nodes : Array[MessageNode]
} derive(Eq, 
Debug)

A branch in a select, plural, or selectordinal message argument.

#
MessageCase::new

source
fn MessageCase::new(selector : String, nodes : Array[MessageNode]) -> MessageCase

#
MessageCase::nodes

source

#
MessageCase::selector

source
fn MessageCase::selector(self : MessageCase) -> String

#
MessageCatalog

source
pub struct MessageCatalog {
  locale : Locale
  messages : Array[CatalogMessage]
} derive(Eq, 
Debug)

An immutable collection of compiled messages for one locale.

#
MessageCatalog::compile

source
fn MessageCatalog::compile(locale : Locale, resources : Array[MessageResource]) -> Result[MessageCatalog, CatalogCompileError]

Parses and validates all messages for a locale.

#
MessageCatalog::contains

source
fn MessageCatalog::contains(self : MessageCatalog, key : String) -> Bool

#
MessageCatalog::get

source
fn MessageCatalog::get(self : MessageCatalog, key : String) -> MessageTemplate?

#
MessageCatalog::is_empty

source
fn MessageCatalog::is_empty(self : MessageCatalog) -> Bool

#
MessageCatalog::keys

source
fn MessageCatalog::keys(self : MessageCatalog) -> Array[String]

#
MessageCatalog::length

source
fn MessageCatalog::length(self : MessageCatalog) -> Int

#
MessageCatalog::locale

source
fn MessageCatalog::locale(self : MessageCatalog) -> Locale

#
MessageCatalog::pseudo_localized

source
fn MessageCatalog::pseudo_localized(self : MessageCatalog, locale : Locale, options? : PseudoOptions) -> MessageCatalog

Creates a pseudo-locale catalog without reparsing or modifying arguments.

#
MessageFormatError

source
pub(all) enum MessageFormatError {
  MissingArgument(String)
  DuplicateArgument(String)
  ExpectedNumber(String)
  ExpectedSelector(String)
  NoMatchingCase(String)
} derive(Eq, 
Debug)

Errors produced while rendering an otherwise valid message template.

#
MessageFormatError::message

source
fn MessageFormatError::message(self : MessageFormatError) -> String

#
MessageNode

source
pub(all) enum MessageNode {
  Text(String)
  Argument(String)
  Select(String, Array[MessageCase])
  Plural(String, Int, PluralKind, Array[MessageCase])
} derive(Eq, 
Debug)

The parsed representation of a localized message template.

Keeping the syntax tree public lets applications cache compiled templates, inspect their arguments, and build tooling without reparsing source text.

#
MessageParseError

source
pub enum MessageParseError {
  UnexpectedEnd(Int, String)
  UnexpectedCharacter(Int, Char)
  ExpectedToken(Int, String)
  EmptyArgument(Int)
  UnknownArgumentType(Int, String)
  MissingOtherCase(Int)
  DuplicateCase(Int, String)
  InvalidOffset(Int, String)
  TrailingContent(Int)
} derive(Eq, 
Debug)

Describes an invalid message template and its character offset.

#
MessageParseError::message

source
fn MessageParseError::message(self : MessageParseError) -> String

#
MessageParseError::position

source
fn MessageParseError::position(self : MessageParseError) -> Int

#
MessageResource

source
pub struct MessageResource {
  key : String
  source : String
} derive(Eq, 
Debug)

An uncompiled message resource supplied by an application.

Catalog compilation parses every source string up front, so syntax errors are reported during application initialization rather than during a request.

#
MessageResource::key

source
fn MessageResource::key(self : MessageResource) -> String

#
MessageResource::new

source
fn MessageResource::new(key : String, source : String) -> MessageResource

#
MessageResource::source

source
fn MessageResource::source(self : MessageResource) -> String

#
MessageTemplate

source
pub struct MessageTemplate {
  source : String
  nodes : Array[MessageNode]
} derive(Eq, 
Debug)

A reusable parsed message template.

#
MessageTemplate::arguments

source
fn MessageTemplate::arguments(self : MessageTemplate) -> Array[String]

Collects argument names in first-use order without duplicates.

#
MessageTemplate::format

source
fn MessageTemplate::format(self : MessageTemplate, locale : Locale, arguments : Array[MessageArgument]) -> Result[String, MessageFormatError]

Renders this template using locale-aware plural rules and numbers.

#
MessageTemplate::node_count

source
fn MessageTemplate::node_count(self : MessageTemplate) -> Int

Returns the number of syntax-tree nodes, including nested branch content.

#
MessageTemplate::nodes

source

#
MessageTemplate::parse

source
fn MessageTemplate::parse(source : String) -> Result[MessageTemplate, MessageParseError]

Parses an ICU-inspired message template.

Supported arguments are simple variables, select, plural, and selectordinal. Plural branches accept exact selectors such as =0 and optional non-negative offsets. Apostrophes quote syntax characters.

#
MessageTemplate::pseudo_localized

source
fn MessageTemplate::pseudo_localized(self : MessageTemplate, options? : PseudoOptions) -> MessageTemplate

Pseudo-localizes literal text while preserving arguments, selectors, plural rules, and the template's original source for diagnostics.

#
MessageTemplate::source

source
fn MessageTemplate::source(self : MessageTemplate) -> String

#
MessageValue

source
pub(all) enum MessageValue {
  StringValue(String)
  IntValue(Int)
  DecimalValue(Decimal)
  BoolValue(Bool)
} derive(Eq, 
Debug)

A runtime value supplied to a localized message.

#
MessageValue::from_bool

source
fn MessageValue::from_bool(value : Bool) -> MessageValue

#
MessageValue::from_decimal

source
fn MessageValue::from_decimal(value : Decimal) -> MessageValue

#
MessageValue::from_int

source
fn MessageValue::from_int(value : Int) -> MessageValue

#
MessageValue::from_string

source
fn MessageValue::from_string(value : String) -> MessageValue

#
NumberFormatter

source
pub struct NumberFormatter {
  locale : Locale
  grouping : Bool
  minimum_integer_digits : Int
  sign_display : SignDisplay
} derive(Eq, 
Debug)

Immutable configuration for localized number output.

#
NumberFormatter::format_int

source
fn NumberFormatter::format_int(self : NumberFormatter, value : Int) -> String

Formats an integer using locale punctuation and grouping.

#
NumberFormatter::locale

source
fn NumberFormatter::locale(self : NumberFormatter) -> Locale

#
NumberFormatter::new

source

#
NumberFormatter::with_grouping

source
fn NumberFormatter::with_grouping(self : NumberFormatter, enabled : Bool) -> NumberFormatter

#
NumberFormatter::with_minimum_integer_digits

source
fn NumberFormatter::with_minimum_integer_digits(self : NumberFormatter, digits : Int) -> NumberFormatter

Sets the minimum number of integer digits, clamped to the range 1–21.

#
NumberFormatter::with_sign_display

source
fn NumberFormatter::with_sign_display(self : NumberFormatter, display : SignDisplay) -> NumberFormatter

#
NumberSymbols

source
pub struct NumberSymbols {
  decimal : String
  group : String
  minus : String
  plus : String
  primary_group : Int
  secondary_group : Int
} derive(Eq, 
Debug)

Symbols and grouping rules used by a numbering system.

#
NumberSymbols::decimal

source
fn NumberSymbols::decimal(self : NumberSymbols) -> String

#
NumberSymbols::group

source
fn NumberSymbols::group(self : NumberSymbols) -> String

#
NumberSymbols::minus

source
fn NumberSymbols::minus(self : NumberSymbols) -> String

#
NumberSymbols::plus

source
fn NumberSymbols::plus(self : NumberSymbols) -> String

#
NumberSymbols::primary_group

source
fn NumberSymbols::primary_group(self : NumberSymbols) -> Int

#
NumberSymbols::secondary_group

source
fn NumberSymbols::secondary_group(self : NumberSymbols) -> Int

#
PercentSpacing

source
pub(all) enum PercentSpacing {
  LocaleDefault
  Compact
  Spaced
} derive(Eq, 
Debug)

Controls whether a percentage suffix is separated from the value.

#
PluralCategory

source
pub(all) enum PluralCategory {
  Zero
  One
  Two
  Few
  Many
  Other
} derive(Eq, 
Debug)

CLDR-compatible plural categories used by message selection.

#
PluralCategory::name

source
fn PluralCategory::name(self : PluralCategory) -> String

#
PluralKind

source
pub(all) enum PluralKind {
  Cardinal
  Ordinal
} derive(Eq, 
Debug)

The kind of plural rule requested by an application.

#
PluralRules

source
pub struct PluralRules {
  locale : Locale
  kind : PluralKind
} derive(Eq, 
Debug)

Reusable plural selector bound to a locale.

#
PluralRules::kind

source
fn PluralRules::kind(self : PluralRules) -> PluralKind

#
PluralRules::locale

source
fn PluralRules::locale(self : PluralRules) -> Locale

#
PluralRules::new

source
fn PluralRules::new(locale : Locale, kind? : PluralKind) -> PluralRules

#
PluralRules::ordinal

source
fn PluralRules::ordinal(locale : Locale) -> PluralRules

Creates rules for ordinal values such as 1st and 23rd.

#
PluralRules::select

source
fn PluralRules::select(self : PluralRules, value : Int) -> PluralCategory

#
PseudoOptions

source
pub struct PseudoOptions {
  accents : Bool
  expand : Bool
  wrap : Bool
} derive(Eq, 
Debug)

Controls how application text is transformed for localization testing.

#
PseudoOptions::accents

source
fn PseudoOptions::accents(self : PseudoOptions) -> Bool

#
PseudoOptions::expands

source
fn PseudoOptions::expands(self : PseudoOptions) -> Bool

#
PseudoOptions::new

source
fn PseudoOptions::new(accents? : Bool, expand? : Bool, wrap? : Bool) -> PseudoOptions

#
PseudoOptions::wraps

source
fn PseudoOptions::wraps(self : PseudoOptions) -> Bool

#
RelativeNumeric

source
pub(all) enum RelativeNumeric {
  Always
  Auto
} derive(Eq, 
Debug)

#
RelativeTimeFormatter

source
pub struct RelativeTimeFormatter {
  locale : Locale
  numeric : RelativeNumeric
  width : ListWidth
} derive(Eq, 
Debug)

#
RelativeTimeFormatter::format

source
fn RelativeTimeFormatter::format(self : RelativeTimeFormatter, value : Int, unit : RelativeUnit) -> String

Formats a signed offset, where negative values are in the past.

#
RelativeTimeFormatter::new

source

#
RelativeTimeFormatter::with_numeric

source

#
RelativeTimeFormatter::with_width

source

#
RelativeUnit

source
pub(all) enum RelativeUnit {
  Second
  Minute
  Hour
  Day
  Week
  Month
  Quarter
  Year
} derive(Eq, 
Debug)

#
ResolvedMessage

source
pub struct ResolvedMessage {
  requested : Locale
  resolved : Locale
  key : String
  template : MessageTemplate
} derive(Eq, 
Debug)

A message together with the locale that ultimately supplied it.

#
ResolvedMessage::key

source
fn ResolvedMessage::key(self : ResolvedMessage) -> String

#
ResolvedMessage::requested_locale

source
fn ResolvedMessage::requested_locale(self : ResolvedMessage) -> Locale

#
ResolvedMessage::resolved_locale

source
fn ResolvedMessage::resolved_locale(self : ResolvedMessage) -> Locale

#
ResolvedMessage::template

source

#
SignDisplay

source
pub(all) enum SignDisplay {
  Auto
  Always
  Never
  ExceptZero
} derive(Eq, 
Debug)

Controls when a localized number includes a sign.

#
UnitFormatter

source
pub struct UnitFormatter {
  locale : Locale
  width : UnitWidth
  number : DecimalFormatter
} derive(Eq, 
Debug)

Locale-aware formatter for measurements and application-facing quantities.

#
UnitFormatter::format

source
fn UnitFormatter::format(self : UnitFormatter, value : Decimal, unit : MeasurementUnit) -> String

Formats a decimal quantity with a localized unit label.

#
UnitFormatter::format_int

source
fn UnitFormatter::format_int(self : UnitFormatter, value : Int, unit : MeasurementUnit) -> String

#
UnitFormatter::locale

source
fn UnitFormatter::locale(self : UnitFormatter) -> Locale

#
UnitFormatter::new

source
fn UnitFormatter::new(locale : Locale) -> UnitFormatter

#
UnitFormatter::with_fraction_digits

source
fn UnitFormatter::with_fraction_digits(self : UnitFormatter, minimum : Int, maximum : Int) -> UnitFormatter

#
UnitFormatter::with_width

source
fn UnitFormatter::with_width(self : UnitFormatter, width : UnitWidth) -> UnitFormatter

#
UnitWidth

source
pub(all) enum UnitWidth {
  UnitLong
  UnitShort
  UnitNarrow
} derive(Eq, 
Debug)

Controls whether a unit is written as a word, abbreviation, or symbol.

#
Weekday

source
pub(all) enum Weekday {
  Monday
  Tuesday
  Wednesday
  Thursday
  Friday
  Saturday
  Sunday
} derive(Compare, Eq, 
Debug)

#
Weekday::iso_number

source
fn Weekday::iso_number(self : Weekday) -> Int

#
audit_catalogs

source
fn audit_catalogs(reference : MessageCatalog, translations : Array[MessageCatalog]) -> CatalogAudit

Compares every translation with a source-of-truth catalog.

Argument order may differ between languages, but names must form the same set so messages cannot fail only after reaching production.

#
best_locale

source
fn best_locale(requested : Locale, supported : Array[Locale], default? : Locale?) -> Locale?

Selects the best supported locale for a requested locale.

#
bool_argument

source
fn bool_argument(name : String, value : Bool) -> MessageArgument

#
cardinal_plural

source
fn cardinal_plural(locale : Locale, value : Int) -> PluralCategory

Selects a cardinal category for an integer.

The implementation covers the major CLDR integer rule families. Languages without grammatical integer plurals safely return other.

#
currency_fraction_digits

source
fn currency_fraction_digits(code : String) -> Int

Returns the conventional number of minor-unit digits for a currency.

#
days_in_month

source
fn days_in_month(year : Int, month : Int) -> Int

#
decimal_argument

source
fn decimal_argument(name : String, coefficient : Int, scale : Int) -> MessageArgument

#
format_byte_size

source
fn format_byte_size(bytes : Int, locale : Locale, style? : ByteSizeStyle, fraction_digits? : Int) -> String

Automatically selects a byte unit using SI (1000) or IEC (1024) scaling.

#
format_currency

source
fn format_currency(locale : Locale, value : Decimal, code : String, display : CurrencyDisplay) -> String

Formats a monetary value using common currency digits and locale placement.

#
format_duration

source
fn format_duration(total_seconds : Int, locale : Locale, width? : UnitWidth, max_parts? : Int) -> String

Formats seconds as a localized compound duration such as 1 hour, 2 minutes or 1小时2分钟.

#
format_int

source
fn format_int(locale : Locale, value : Int) -> String

Convenience entry point with default options.

#
format_list

source
fn format_list(locale : Locale, values : Array[String]) -> String

#
format_message

source
fn format_message(locale : Locale, source : String, arguments : Array[MessageArgument]) -> Result[String, String]

Parses and formats a one-off template.

Applications that reuse a message should parse it once and retain the MessageTemplate instead.

#
int_argument

source
fn int_argument(name : String, value : Int) -> MessageArgument

#
is_leap_year

source
fn is_leap_year(year : Int) -> Bool

#
message_resource

source
fn message_resource(key : String, source : String) -> MessageResource

#
number_symbols

source
fn number_symbols(locale : Locale) -> NumberSymbols

Returns practical decimal symbols for a locale.

MoonLocale intentionally keeps Latin digits as its portable default while selecting punctuation and grouping conventions from the locale.

#
ordinal_plural

source
fn ordinal_plural(locale : Locale, value : Int) -> PluralCategory

Selects an ordinal category for an integer.

#
pseudo_localize

source
fn pseudo_localize(text : String, options? : PseudoOptions) -> String

Transforms plain UI text so untranslated strings and cramped layouts stand out during testing.

#
string_argument

source
fn string_argument(name : String, value : String) -> MessageArgument

#
valid_locales

source
fn valid_locales(tags : Array[String]) -> Array[Locale]

Parses a list of supported tags and ignores invalid entries.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io