Numbers in words

use number_words.qweruse number_words, number_ordinal_words from number_words      // Quillo 0.6: only these

num2words = "1.2"

// A cheque's amount in words, an invoice total in French, and chapter numbers in Roman numerals.////   quillo run number_words.qwe      then open http://localhost:8080/cheque?amount=1112.50use "number_words.qwer"route GET /cheque ? { amount: str, currency: str = "USD" } = { amount, words: number_money_words(amount, currency, "en")? }route GET /words = {    plain: number_words(112, "en")?,    french: number_words(1999, "fr")?,    belgian: number_words(70, "fr_BE")?,    euros: number_money_words(42.3, "EUR", "fr")?,    place: number_ordinal_words(21, "en")?,    year: number_year_words(2026, "en")?,}route GET /chapters = [1, 4, 9, 14, 2026] | map((n) => { n, roman: number_roman(n)?, back: number_from_roman(number_roman(n)?)? })

//! Numbers written in words, for cheques, invoices and contracts ("one hundred twelve dollars and fifty cents"), in English, French and Ukrainian, plus Roman numerals both ways.//! version: 1.0.0//!//! [dependencies]//! num2words = "1.2"use num2words::{Currency, Lang, Num2Words};fn lang(l: &str) -> Result<Lang, String> {    match l.trim() {        "" | "en" => Ok(Lang::English),        "fr" => Ok(Lang::French),        "fr_BE" | "fr-BE" => Ok(Lang::French_BE),        "fr_CH" | "fr-CH" => Ok(Lang::French_CH),        "uk" => Ok(Lang::Ukrainian),        o => Err(format!("language is \"en\", \"fr\", \"fr_BE\", \"fr_CH\" or \"uk\", not {:?}", o)),    }}fn num(n: &serde_json::Value) -> Result<Num2Words, String> {    let s = match n {        serde_json::Value::Number(x) => x.to_string(),        serde_json::Value::String(s) => s.trim().replace([',', '_', ' '], ""),        _ => return Err("a number, or a number as text".into()),    };    if s.len() > 60 {        return Err("numbers up to 60 digits".into());    }    Num2Words::parse(&s).ok_or_else(|| format!("{:?} is not a number", s))}/// `number` (an int, a float, or a number as text such as "1,250.75") in words in `language` ("en", "fr", "fr_BE", "fr_CH", "uk"): 112 is "one hundred twelve", 42 in French "quarante-deux", 1.5 is "one point five".pub fn number_words(number: serde_json::Value, language: &str) -> Result<String, String> {    num(&number)?.lang(lang(language)?).cardinal().to_words().map_err(|e| e.to_string())}/// `number` as an ordinal in words: 21 is "twenty-first", in French "vingt-et-unième". Whole numbers from 0.pub fn number_ordinal_words(number: i64, language: &str) -> Result<String, String> {    Num2Words::new(number).lang(lang(language)?).ordinal().to_words().map_err(|e| e.to_string())}/// An amount of money in words, as written on a cheque: 112.5 with "USD" is "one hundred twelve dollars and fifty cents". `currency` is an ISO code: USD, EUR, GBP, CAD, AUD, CHF, JPY, INR, MXN and 30 more.pub fn number_money_words(amount: serde_json::Value, currency: &str, language: &str) -> Result<String, String> {    let code = currency.trim().to_uppercase();    let c: Currency = if code == "USD" { Currency::DOLLAR } else { code.parse().map_err(|_| format!("no currency {:?}", currency))? };    num(&amount)?.lang(lang(language)?).currency(c).to_words().map_err(|e| e.to_string())}/// A year as it is said: 1999 is "nineteen ninety-nine", 2026 is "twenty twenty-six".pub fn number_year_words(year: i64, language: &str) -> Result<String, String> {    Num2Words::new(year).lang(lang(language)?).year().to_words().map_err(|e| e.to_string())}/// `n` in Roman numerals, from 1 to 3999: 2026 is "MMXXVI", 4 is "IV".pub fn number_roman(n: i64) -> Result<String, String> {    if !(1..=3999).contains(&n) {        return Err("Roman numerals go from 1 to 3999".into());    }    let mut n = n;    let mut out = String::new();    for (v, s) in [(1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"), (90, "XC"), (50, "L"), (40, "XL"), (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I")] {        while n >= v {            out.push_str(s);            n -= v;        }    }    Ok(out)}/// The number a Roman numeral stands for, case ignored: "MMXXVI" is 2026. Only the standard forms are read ("IIII" is an error).pub fn number_from_roman(text: &str) -> Result<i64, String> {    let t = text.trim().to_uppercase();    let val = |c: char| match c { 'I' => Some(1), 'V' => Some(5), 'X' => Some(10), 'L' => Some(50), 'C' => Some(100), 'D' => Some(500), 'M' => Some(1000), _ => None };    let digits: Vec<i64> = t.chars().map(|c| val(c).ok_or_else(|| format!("{:?} is not a Roman numeral", text))).collect::<Result<_, _>>()?;    if digits.is_empty() {        return Err("an empty numeral".into());    }    let mut total = 0;    for (i, &d) in digits.iter().enumerate() {        if digits.get(i + 1).map_or(false, |&next| next > d) { total -= d } else { total += d }    }    // Only the standard spelling counts: writing the number back must give the same text.    if number_roman(total).ok().as_deref() != Some(t.as_str()) {        return Err(format!("{:?} is not a standard Roman numeral", text));    }    Ok(total)}