Skip to content

std::plural

Plural rules: which grammatical form a number takes in a language. English has two cardinal forms (1 coin, 2 coins). Polish has three for whole numbers and one more for fractions, Arabic has six and Japanese one. PluralCategory.cardinal(count, locale) gives the CLDR category a count selects, and PluralCategory.ordinal the one an ordinal (1st, 2nd) selects. The rules are CLDR’s, from the release Nomi pins.

A count is an Int or a Decimal. A Decimal’s fraction digits are part of the number a reader sees, so 1.0d is not 1: English says “1 coin” and “1.0 coins”. Float is not a count, because its category depends on how many digits are shown, which a Float does not know; round it to a Decimal first (Float.to_decimal).

Import with import std::plural.

Types

Interfaces

LocaleCardinal
en1 is One; 0, 2 and 1.0 are Other
fr0, 1 and 1.5 are One; 1000000 is Many
pl1 is One; 2–4, 22–24 are Few; 0, 5–21, 25 are Many; 1.5 is Other
ar0 Zero, 1 One, 2 Two, 3–10 Few, 11–99 Many, 100 Other
jaevery number is Other

In English, ordinals 1, 21 and 101 are One, 2 and 22 are Two, 3 and 23 are Few, and 4 and 11 to 13 are Other.

A locale’s rules are the first CLDR rule set on its plural fallback chain, else root’s, under which every number is Other. The plural chain follows CLDR’s parent locales for the plurals component, which in CLDR 48.2 is truncation alone: pt-BR uses pt’s rules, pt-PT has its own, and zh-Hant-HK uses zh’s.

enum PluralCategory
    Zero
    One
    Two
    Few
    Many
    Other
end

One of CLDR’s six plural categories. Every language uses Other; which of the rest it uses, and for which numbers, is the language’s rules. Display gives CLDR’s keyword (one, few).

assert Display.to_string(PluralCategory.Few) == "few"

impl Display for PluralCategory

fn to_string(category: PluralCategory) -> String

impl Display.to_string

fn cardinal(value: PluralOperand, locale: Locale) -> PluralCategory

type function on PluralCategory

The cardinal category value selects in locale: the form of a noun counted by it. CLDR’s operands are read off the number’s digits exactly, visible trailing zeros included.

assert PluralCategory.cardinal(1, Locale"en") == PluralCategory.One
assert PluralCategory.cardinal(2, Locale"en") == PluralCategory.Other
assert PluralCategory.cardinal(1.0d, Locale"en") == PluralCategory.Other
assert PluralCategory.cardinal(3, Locale"pl") == PluralCategory.Few
assert PluralCategory.cardinal(5, Locale"pl") == PluralCategory.Many
assert PluralCategory.cardinal(0, Locale"fr") == PluralCategory.One
assert PluralCategory.cardinal(1.5d, Locale"fr") == PluralCategory.One
assert PluralCategory.cardinal(1000000, Locale"fr") == PluralCategory.Many
assert PluralCategory.cardinal(22, Locale"pl") == PluralCategory.Few
assert PluralCategory.cardinal(25, Locale"pl") == PluralCategory.Many
assert PluralCategory.cardinal(1.5d, Locale"pl") == PluralCategory.Other
assert PluralCategory.cardinal(0, Locale"ar") == PluralCategory.Zero
assert PluralCategory.cardinal(2, Locale"ar") == PluralCategory.Two
assert PluralCategory.cardinal(11, Locale"ar") == PluralCategory.Many
assert PluralCategory.cardinal(100, Locale"ar") == PluralCategory.Other
assert PluralCategory.cardinal(1, Locale"ja") == PluralCategory.Other
assert PluralCategory.cardinal(Int.pow(10, 30), Locale"fr") == PluralCategory.Many
fn ordinal(value: Int, locale: Locale) -> PluralCategory

type function on PluralCategory

The ordinal category value selects in locale: the form of “1st”, “2nd”, “3rd” and “4th”.

assert PluralCategory.ordinal(1, Locale"en") == PluralCategory.One
assert PluralCategory.ordinal(2, Locale"en") == PluralCategory.Two
assert PluralCategory.ordinal(3, Locale"en") == PluralCategory.Few
assert PluralCategory.ordinal(11, Locale"en") == PluralCategory.Other
assert PluralCategory.ordinal(21, Locale"en") == PluralCategory.One
assert PluralCategory.ordinal(101, Locale"en") == PluralCategory.One
assert PluralCategory.ordinal(22, Locale"en") == PluralCategory.Two
assert PluralCategory.ordinal(23, Locale"en") == PluralCategory.Few
assert PluralCategory.ordinal(13, Locale"en") == PluralCategory.Other
fn cardinals(locale: Locale) -> Set<PluralCategory>

type function on PluralCategory

The cardinal categories locale’s rules can select, Other always among them.

assert PluralCategory.cardinals(Locale"ja") == [PluralCategory.Other]
assert PluralCategory.cardinals(Locale"en") == [PluralCategory.One, PluralCategory.Other]
fn ordinals(locale: Locale) -> Set<PluralCategory>

type function on PluralCategory

The ordinal categories locale’s rules can select.

assert PluralCategory.ordinals(Locale"en") == [
    PluralCategory.One,
    PluralCategory.Two,
    PluralCategory.Few,
    PluralCategory.Other,
]

impl Debug for PluralCategory

fn inspect(value: PluralCategory) -> String

impl Debug.inspect

impl Equatable for PluralCategory

fn equal(a: PluralCategory, b: PluralCategory) -> Bool

impl Equatable.equal

impl Hashable for PluralCategory

fn hash(value: PluralCategory) -> Int

impl Hashable.hash

interface PluralOperand
    fn plural_operand(value: self) -> Decimal
end

A number that selects a plural category: Int and Decimal. A type implements it by giving the number as its reader sees it, as a Decimal whose scale is the count of visible fraction digits. The sign does not matter. CLDR’s operands (n, i, v, w, f, t, e) are computed exactly from that Decimal’s digits, at any size, and e is always 0. Float does not implement it.

fn plural_operand(value: self) -> Decimal

interface PluralOperand